the-moby-effect
Version:
Moby/Docker API client built using effect-ts
288 lines (260 loc) • 8.24 kB
text/typescript
/**
* IPv6 address schema.
*
* @since 1.0.0
*/
import * as Brand from "effect/Brand";
import * as Effect from "effect/Effect";
import * as Schema from "effect/Schema";
import * as IPv4 from "./ipv4.js";
/**
* @since 1.0.0
* @category Regular expressions
* @see https://github.com/nodejs/node/blob/e08a654fae0ecc91678819e0b62a2e014bad3339/lib/internal/net.js#L21-L31
*/
export const IPv6Segment = "(?:[0-9a-fA-F]{1,4})";
/**
* @since 1.0.0
* @category Regular expressions
*/
export const IPv6Regex = new RegExp(
"^(?:" +
`(?:${IPv6Segment}:){7}(?:${IPv6Segment}|:)|` +
`(?:${IPv6Segment}:){6}(?:${IPv4.IPv4String}|:${IPv6Segment}|:)|` +
`(?:${IPv6Segment}:){5}(?::${IPv4.IPv4String}|(?::${IPv6Segment}){1,2}|:)|` +
`(?:${IPv6Segment}:){4}(?:(?::${IPv6Segment}){0,1}:${IPv4.IPv4String}|(?::${IPv6Segment}){1,3}|:)|` +
`(?:${IPv6Segment}:){3}(?:(?::${IPv6Segment}){0,2}:${IPv4.IPv4String}|(?::${IPv6Segment}){1,4}|:)|` +
`(?:${IPv6Segment}:){2}(?:(?::${IPv6Segment}){0,3}:${IPv4.IPv4String}|(?::${IPv6Segment}){1,5}|:)|` +
`(?:${IPv6Segment}:){1}(?:(?::${IPv6Segment}){0,4}:${IPv4.IPv4String}|(?::${IPv6Segment}){1,6}|:)|` +
`(?::(?:(?::${IPv6Segment}){0,5}:${IPv4.IPv4String}|(?::${IPv6Segment}){1,7}|:))` +
")(?:%[0-9a-zA-Z-.:]{1,})?$"
);
/**
* @since 1.0.0
* @category Api interface
*/
export interface $IPv6Family extends Schema.Literal<["ipv6"]> {}
/**
* @since 1.0.0
* @category Decoded types
*/
export type IPv6Family = Schema.Schema.Type<$IPv6Family>;
/**
* @since 1.0.0
* @category Schemas
*/
export const IPv6Family: $IPv6Family = Schema.Literal("ipv6").annotations({
identifier: "IPv6Family",
description: "An ipv6 family",
});
/**
* @since 1.0.0
* @category Api interface
*/
export interface $IPv6String extends Schema.filter<Schema.Schema<string, string, never>> {}
/**
* An IPv6 address in string format.
*
* @since 1.0.0
* @category Schemas
*/
export const IPv6String: $IPv6String = Schema.String.pipe(Schema.pattern(IPv6Regex));
/**
* @since 1.0.0
* @category Branded types
*/
export type IPv6Brand = string & Brand.Brand<"IPv6">;
/**
* @since 1.0.0
* @category Branded constructors
*/
export const IPv6Brand = Brand.nominal<IPv6Brand>();
/**
* @since 1.0.0
* @category Api interface
*/
export interface $IPv6
extends Schema.transform<
Schema.filter<Schema.Schema<string, string, never>>,
Schema.Struct<{
family: $IPv6Family;
ip: Schema.BrandSchema<IPv6Brand, Brand.Brand.Unbranded<IPv6Brand>, never>;
}>
> {}
/**
* @since 1.0.0
* @category Decoded types
*/
export type IPv6 = Schema.Schema.Type<$IPv6>;
/**
* @since 1.0.0
* @category Encoded types
*/
export type IPv6Encoded = Schema.Schema.Encoded<$IPv6>;
/**
* An IPv6 address.
*
* @since 1.0.0
* @category Schemas
* @example
* import * as Schema from "effect/Schema";
* import { IPv6 } from "the-moby-effect/schemas/index.js";
*
* const decodeIPv6 = Schema.decodeSync(IPv6);
* assert.deepEqual(decodeIPv6("2001:0db8:85a3:0000:0000:8a2e:0370:7334"), {
* family: "ipv6",
* ip: "2001:0db8:85a3:0000:0000:8a2e:0370:7334",
* });
*
* assert.throws(() =>
* decodeIPv6("2001:0db8:85a3:0000:0000:8a2e:0370:7334:")
* );
* assert.throws(() => decodeIPv6("2001::85a3::0000::0370:7334"));
* assert.doesNotThrow(() =>
* decodeIPv6("2001:0db8:85a3:0000:0000:8a2e:0370:7334")
* );
*/
export const IPv6: $IPv6 = Schema.transform(
IPv6String,
Schema.Struct({
family: IPv6Family,
ip: Schema.String.pipe(Schema.fromBrand(IPv6Brand)),
}),
{
encode: ({ ip }) => ip,
decode: (ip) => ({ ip, family: "ipv6" }) as const,
}
).annotations({
identifier: "IPv6",
description: "An ipv6 address",
});
/**
* @since 1.0.0
* @category Branded types
*/
export type IPv6BigintBrand = bigint & Brand.Brand<"IPv6Bigint">;
/**
* @since 1.0.0
* @category Branded constructors
*/
export const IPv6BigintBrand = Brand.nominal<IPv6BigintBrand>();
/**
* @since 1.0.0
* @category Api interface
*/
export interface $IPv6Bigint
extends Schema.transformOrFail<
$IPv6,
Schema.Struct<{
family: $IPv6Family;
value: Schema.BrandSchema<IPv6BigintBrand, Brand.Brand.Unbranded<IPv6BigintBrand>, never>;
}>,
never
> {}
/**
* @since 1.0.0
* @category Decoded types
*/
export type IPv6Bigint = Schema.Schema.Type<$IPv6Bigint>;
/**
* @since 1.0.0
* @category Encoded types
*/
export type IPv6BigintEncoded = Schema.Schema.Encoded<$IPv6Bigint>;
/**
* An IPv6 as a bigint.
*
* @since 1.0.0
* @category Schemas
* @example
* import * as Schema from "effect/Schema";
* import {
* IPv6Bigint,
* IPv6BigintBrand,
* } from "the-moby-effect/schemas/IPv6.js";
*
* const y: IPv6BigintBrand = IPv6BigintBrand(748392749382n);
* assert.strictEqual(y, 748392749382n);
*
* const decodeIPv6Bigint = Schema.decodeSync(IPv6Bigint);
* const encodeIPv6Bigint = Schema.encodeSync(IPv6Bigint);
*
* assert.deepEqual(
* decodeIPv6Bigint("4cbd:ff70:e62b:a048:686c:4e7e:a68a:c377"),
* { value: 102007852745154114519525620108359287671n, family: "ipv6" }
* );
* assert.deepEqual(
* decodeIPv6Bigint("d8c6:3feb:46e6:b80c:5a07:6227:ac19:caf6"),
* { value: 288142618299897818094313964584331496182n, family: "ipv6" }
* );
*
* assert.deepEqual(
* encodeIPv6Bigint({
* value: IPv6BigintBrand(102007852745154114519525620108359287671n),
* family: "ipv6",
* }),
* "4cbd:ff70:e62b:a048:686c:4e7e:a68a:c377"
* );
* assert.deepEqual(
* encodeIPv6Bigint({
* value: IPv6BigintBrand(288142618299897818094313964584331496182n),
* family: "ipv6",
* }),
* "d8c6:3feb:46e6:b80c:5a07:6227:ac19:caf6"
* );
*/
export const IPv6Bigint: $IPv6Bigint = Schema.transformOrFail(
IPv6,
Schema.Struct({
family: IPv6Family,
value: Schema.BigIntFromSelf.pipe(Schema.fromBrand(IPv6BigintBrand)),
}),
{
encode: ({ value }) => {
const hex = value.toString(16).padStart(32, "0");
const groups = [];
for (let i = 0; i < 8; i++) {
groups.push(hex.slice(i * 4, (i + 1) * 4));
}
return Schema.decode(IPv6)(groups.join(":")).pipe(Effect.mapError(({ issue }) => issue));
},
decode: ({ ip }) => {
function paddedHex(octet: string): string {
return parseInt(octet, 16).toString(16).padStart(4, "0");
}
let groups: Array<string> = [];
const halves = ip.split("::");
if (halves.length === 2) {
let first = halves[0]!.split(":");
let last = halves[1]!.split(":");
if (first.length === 1 && first[0] === "") {
first = [];
}
if (last.length === 1 && last[0] === "") {
last = [];
}
const remaining = 8 - (first.length + last.length);
if (!remaining) {
throw new Error("Error parsing groups");
}
groups = groups.concat(first);
for (let i = 0; i < remaining; i++) {
groups.push("0");
}
groups = groups.concat(last);
} else if (halves.length === 1) {
groups = ip.split(":");
} else {
throw new Error("Too many :: groups found");
}
groups = groups.map((group: string) => parseInt(group, 16).toString(16));
if (groups.length !== 8) {
throw new Error("Invalid number of groups");
}
return Effect.succeed({ value: BigInt(`0x${groups.map(paddedHex).join("")}`), family: "ipv6" } as const);
},
}
).annotations({
identifier: "IPv6Bigint",
description: "An ipv6 address as a bigint",
});