the-moby-effect 1.45.0-alpha.8 → 1.48.0

package/src/internal/schemas/id.ts

@@ -0,0 +1,73 @@
+/**
+ * Id schemas.
+ *
+ * @since 1.0.0
+ */
+
+import * as Schema from "effect/Schema";
+
+/**
+ * @since 1.0.0
+ * @category Id Schemas
+ */
+export const ConfigId = Schema.String.pipe(Schema.brand("ConfigId"));
+
+/**
+ * @since 1.0.0
+ * @category Id Schemas
+ */
+export const ContainerId = Schema.String.pipe(Schema.brand("ContainerId"));
+
+/**
+ * @since 1.0.0
+ * @category Id Schemas
+ */
+export const ExecId = Schema.String.pipe(Schema.brand("ExecId"));
+
+/**
+ * @since 1.0.0
+ * @category Id Schemas
+ */
+export const ImageId = Schema.String.pipe(Schema.brand("ImageId"));
+
+/**
+ * @since 1.0.0
+ * @category Id Schemas
+ */
+export const NetworkId = Schema.String.pipe(Schema.brand("NetworkId"));
+
+/**
+ * @since 1.0.0
+ * @category Id Schemas
+ */
+export const NodeId = Schema.String.pipe(Schema.brand("NodeId"));
+
+/**
+ * @since 1.0.0
+ * @category Id Schemas
+ */
+export const PluginId = Schema.String.pipe(Schema.brand("PluginId"));
+
+/**
+ * @since 1.0.0
+ * @category Id Schemas
+ */
+export const SecretId = Schema.String.pipe(Schema.brand("SecretId"));
+
+/**
+ * @since 1.0.0
+ * @category Id Schemas
+ */
+export const ServiceId = Schema.String.pipe(Schema.brand("ServiceId"));
+
+/**
+ * @since 1.0.0
+ * @category Id Schemas
+ */
+export const TaskId = Schema.String.pipe(Schema.brand("TaskId"));
+
+/**
+ * @since 1.0.0
+ * @category Id Schemas
+ */
+export const VolumeId = Schema.String.pipe(Schema.brand("VolumeId"));

package/src/internal/schemas/index.ts

@@ -0,0 +1,54 @@
+export * as AddressSchemas from "./address.js";
+export * as CidrBlockSchemas from "./cidrBlock.js";
+export * as CidrBlockMaskSchemas from "./cidrBlockMask.js";
+export * as FamilySchemas from "./family.js";
+export * as IdSchemas from "./id.js";
+export * as Int16Schemas from "./int16.js";
+export * as Int32Schemas from "./int32.js";
+export * as Int64Schemas from "./int64.js";
+export * as Int8Schemas from "./int8.js";
+export * as IPv4Schemas from "./ipv4.js";
+export * as IPv6Schemas from "./ipv6.js";
+export * as MacSchemas from "./mac.js";
+export * as PortSchemas from "./port.js";
+export * as UInt16Schemas from "./uInt16.js";
+export * as UInt32Schemas from "./uInt32.js";
+export * as UInt64Schemas from "./uInt64.js";
+export * as UInt8Schemas from "./uInt8.js";
+
+export { Address, AddressBigint, AddressString } from "./address.js";
+export {
+    CidrBlock,
+    CidrBlockFromString,
+    IPv4CidrBlock,
+    IPv4CidrBlockFromString,
+    IPv6CidrBlock,
+    IPv6CidrBlockFromString,
+} from "./cidrBlock.js";
+export { IPv4CidrMask, IPv6CidrMask } from "./cidrBlockMask.js";
+export { Family } from "./family.js";
+export {
+    ConfigId,
+    ContainerId,
+    ExecId,
+    ImageId,
+    NetworkId,
+    NodeId,
+    PluginId,
+    SecretId,
+    ServiceId,
+    TaskId,
+    VolumeId,
+} from "./id.js";
+export { Int16 } from "./int16.js";
+export { Int32 } from "./int32.js";
+export { Int64 } from "./int64.js";
+export { Int8 } from "./int8.js";
+export { IPv4, IPv4Bigint, IPv4String } from "./ipv4.js";
+export { IPv6, IPv6Bigint, IPv6String } from "./ipv6.js";
+export { MacAddress } from "./mac.js";
+export { Port } from "./port.js";
+export { UInt16 } from "./uInt16.js";
+export { UInt32 } from "./uInt32.js";
+export { UInt64 } from "./uInt64.js";
+export { UInt8 } from "./uInt8.js";

package/src/internal/schemas/int16.ts

@@ -0,0 +1,45 @@
+/**
+ * 16bit signed integer schema.
+ *
+ * @since 1.0.0
+ */
+
+import * as Brand from "effect/Brand";
+import * as Function from "effect/Function";
+import * as Schema from "effect/Schema";
+
+/**
+ * @since 1.0.0
+ * @category Branded types
+ */
+export type Int16Brand = number & Brand.Brand<"Int16">;
+
+/**
+ * @since 1.0.0
+ * @category Branded constructors
+ */
+export const Int16Brand: Brand.Brand.Constructor<Int16Brand> = Brand.nominal<Int16Brand>();
+
+/**
+ * @since 1.0.0
+ * @category Api interface
+ */
+export interface $Int16 extends Schema.Annotable<$Int16, Int16Brand, Brand.Brand.Unbranded<Int16Brand>, never> {}
+
+/**
+ * 16bit signed integer.
+ *
+ * @since 1.0.0
+ * @category Schemas
+ */
+export const Int16: $Int16 = Function.pipe(
+    Schema.Int,
+    Schema.greaterThanOrEqualTo(-(2 ** 15)),
+    Schema.lessThanOrEqualTo(2 ** 15 - 1),
+    Schema.fromBrand(Int16Brand),
+    Schema.annotations({
+        identifier: "Int16",
+        title: "16-bit signed integer",
+        description: "A 16-bit signed integer.",
+    })
+);

package/src/internal/schemas/int32.ts

@@ -0,0 +1,45 @@
+/**
+ * 32bit signed integer schema.
+ *
+ * @since 1.0.0
+ */
+
+import * as Brand from "effect/Brand";
+import * as Function from "effect/Function";
+import * as Schema from "effect/Schema";
+
+/**
+ * @since 1.0.0
+ * @category Branded types
+ */
+export type Int32Brand = number & Brand.Brand<"Int32">;
+
+/**
+ * @since 1.0.0
+ * @category Branded constructors
+ */
+export const Int32Brand: Brand.Brand.Constructor<Int32Brand> = Brand.nominal<Int32Brand>();
+
+/**
+ * @since 1.0.0
+ * @category Api interface
+ */
+export interface $Int32 extends Schema.Annotable<$Int32, Int32Brand, Brand.Brand.Unbranded<Int32Brand>, never> {}
+
+/**
+ * 32bit signed integer.
+ *
+ * @since 1.0.0
+ * @category Schemas
+ */
+export const Int32: $Int32 = Function.pipe(
+    Schema.Int,
+    Schema.greaterThanOrEqualTo(-(2 ** 31)),
+    Schema.lessThanOrEqualTo(2 ** 31 - 1),
+    Schema.fromBrand(Int32Brand),
+    Schema.annotations({
+        identifier: "Int32",
+        title: "32-bit signed integer",
+        description: "A 32-bit signed integer.",
+    })
+);

package/src/internal/schemas/int64.ts

@@ -0,0 +1,45 @@
+/**
+ * 64bit signed integer schema.
+ *
+ * @since 1.0.0
+ */
+
+import * as Brand from "effect/Brand";
+import * as Function from "effect/Function";
+import * as Schema from "effect/Schema";
+
+/**
+ * @since 1.0.0
+ * @category Branded types
+ */
+export type Int64Brand = number & Brand.Brand<"Int64">;
+
+/**
+ * @since 1.0.0
+ * @category Branded constructors
+ */
+export const Int64Brand: Brand.Brand.Constructor<Int64Brand> = Brand.nominal<Int64Brand>();
+
+/**
+ * @since 1.0.0
+ * @category Api interface
+ */
+export interface $Int64 extends Schema.Annotable<$Int64, Int64Brand, Brand.Brand.Unbranded<Int64Brand>, never> {}
+
+/**
+ * 64bit signed integer.
+ *
+ * @since 1.0.0
+ * @category Schemas
+ */
+export const Int64: $Int64 = Function.pipe(
+    Schema.Number,
+    Schema.greaterThanOrEqualTo(-(2 ** 63)),
+    Schema.lessThanOrEqualTo(2 ** 63 - 1),
+    Schema.fromBrand(Int64Brand),
+    Schema.annotations({
+        identifier: "Int64",
+        title: "64-bit signed integer",
+        description: "A 64-bit signed integer.",
+    })
+);

package/src/internal/schemas/int8.ts

@@ -0,0 +1,45 @@
+/**
+ * 8bit signed integer schema.
+ *
+ * @since 1.0.0
+ */
+
+import * as Brand from "effect/Brand";
+import * as Function from "effect/Function";
+import * as Schema from "effect/Schema";
+
+/**
+ * @since 1.0.0
+ * @category Branded types
+ */
+export type Int8Brand = number & Brand.Brand<"Int8">;
+
+/**
+ * @since 1.0.0
+ * @category Branded constructors
+ */
+export const Int8Brand: Brand.Brand.Constructor<Int8Brand> = Brand.nominal<Int8Brand>();
+
+/**
+ * @since 1.0.0
+ * @category Api interface
+ */
+export interface $Int8 extends Schema.Annotable<$Int8, Int8Brand, Brand.Brand.Unbranded<Int8Brand>, never> {}
+
+/**
+ * 8bit signed integer.
+ *
+ * @since 1.0.0
+ * @category Schemas
+ */
+export const Int8: $Int8 = Function.pipe(
+    Schema.Int,
+    Schema.greaterThanOrEqualTo(-(2 ** 7)),
+    Schema.lessThanOrEqualTo(2 ** 7 - 1),
+    Schema.fromBrand(Int8Brand),
+    Schema.annotations({
+        identifier: "Int8",
+        title: "8-bit signed integer",
+        description: "An 8-bit signed integer.",
+    })
+);

package/src/internal/schemas/ipv4.ts

@@ -0,0 +1,251 @@
+/**
+ * IPv4 address schema.
+ *
+ * @since 1.0.0
+ */
+
+import * as Array from "effect/Array";
+import * as Brand from "effect/Brand";
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import * as Schema from "effect/Schema";
+import * as String from "effect/String";
+
+/**
+ * @since 1.0.0
+ * @category Regular expressions
+ * @see https://github.com/nodejs/node/blob/e08a654fae0ecc91678819e0b62a2e014bad3339/lib/internal/net.js#L16-L18
+ */
+export const IPv4Segment = "(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])";
+
+/**
+ * @since 1.0.0
+ * @category Regular expressions
+ */
+export const IPv4StringRegex = `(?:${IPv4Segment}\\.){3}${IPv4Segment}`;
+
+/**
+ * @since 1.0.0
+ * @category Regular expressions
+ */
+export const IPv4Regex = new RegExp(`^${IPv4StringRegex}$`);
+
+/**
+ * @since 1.0.0
+ * @category Api interface
+ */
+export interface $IPv4Family extends Schema.Literal<["ipv4"]> {}
+
+/**
+ * @since 1.0.0
+ * @category Decoded types
+ */
+export type IPv4Family = Schema.Schema.Type<$IPv4Family>;
+
+/**
+ * @since 1.0.0
+ * @category Schemas
+ */
+export const IPv4Family: $IPv4Family = Schema.Literal("ipv4").annotations({
+    identifier: "IPv4Family",
+    description: "An ipv4 family",
+});
+
+/**
+ * @since 1.0.0
+ * @category Api interface
+ */
+export interface $IPv4String extends Schema.filter<Schema.Schema<string, string, never>> {}
+
+/**
+ * An IPv4 address in dot-decimal notation with no leading zeros.
+ *
+ * @since 1.0.0
+ * @category Schemas
+ */
+export const IPv4String: $IPv4String = Schema.String.pipe(Schema.pattern(IPv4Regex));
+
+/**
+ * @since 1.0.0
+ * @category Branded types
+ */
+export type IPv4Brand = string & Brand.Brand<"IPv4">;
+
+/**
+ * @since 1.0.0
+ * @category Branded constructors
+ */
+export const IPv4Brand = Brand.nominal<IPv4Brand>();
+
+/**
+ * @since 1.0.0
+ * @category Api interface
+ */
+export interface $IPv4
+    extends Schema.transform<
+        Schema.filter<Schema.Schema<string, string, never>>,
+        Schema.Struct<{
+            family: $IPv4Family;
+            ip: Schema.BrandSchema<IPv4Brand, Brand.Brand.Unbranded<IPv4Brand>, never>;
+        }>
+    > {}
+
+/**
+ * @since 1.0.0
+ * @category Decoded types
+ */
+export type IPv4 = Schema.Schema.Type<$IPv4>;
+
+/**
+ * @since 1.0.0
+ * @category Encoded types
+ */
+export type IPv4Encoded = Schema.Schema.Encoded<$IPv4>;
+
+/**
+ * An IPv4 address.
+ *
+ * @since 1.0.0
+ * @category Schemas
+ * @example
+ *     import * as Schema from "effect/Schema";
+ *     import { IPv4 } from "the-moby-effect/schemas/index.js";
+ *
+ *     const decodeIPv4 = Schema.decodeSync(IPv4);
+ *     assert.deepEqual(decodeIPv4("1.1.1.1"), {
+ *         family: "ipv4",
+ *         ip: "1.1.1.1",
+ *     });
+ *
+ *     assert.throws(() => decodeIPv4("1.1.a.1"));
+ *     assert.doesNotThrow(() => decodeIPv4("1.1.1.2"));
+ */
+export const IPv4: $IPv4 = Schema.transform(
+    IPv4String,
+    Schema.Struct({
+        family: IPv4Family,
+        ip: Schema.String.pipe(Schema.fromBrand(IPv4Brand)),
+    }),
+    {
+        encode: ({ ip }) => ip,
+        decode: (ip) => ({ ip, family: "ipv4" }) as const,
+    }
+).annotations({
+    identifier: "IPv4",
+    title: "An ipv4 address",
+    description: "An ipv4 address in dot-decimal notation with no leading zeros",
+});
+
+/**
+ * @since 1.0.0
+ * @category Branded types
+ */
+export type IPv4BigintBrand = bigint & Brand.Brand<"IPv4Bigint">;
+
+/**
+ * @since 1.0.0
+ * @category Branded constructors
+ */
+export const IPv4BigintBrand = Brand.nominal<IPv4BigintBrand>();
+
+/**
+ * @since 1.0.0
+ * @category Api interface
+ */
+export interface $IPv4Bigint
+    extends Schema.transformOrFail<
+        $IPv4,
+        Schema.Struct<{
+            family: $IPv4Family;
+            value: Schema.BrandSchema<IPv4BigintBrand, Brand.Brand.Unbranded<IPv4BigintBrand>, never>;
+        }>,
+        never
+    > {}
+
+/**
+ * @since 1.0.0
+ * @category Decoded types
+ */
+export type IPv4Bigint = Schema.Schema.Type<$IPv4Bigint>;
+
+/**
+ * @since 1.0.0
+ * @category Encoded types
+ */
+export type IPv4BigintEncoded = Schema.Schema.Encoded<$IPv4Bigint>;
+
+/**
+ * An IPv4 as a bigint.
+ *
+ * @since 1.0.0
+ * @category Schemas
+ * @example
+ *     import * as Schema from "effect/Schema";
+ *     import {
+ *         IPv4Bigint,
+ *         IPv4BigintBrand,
+ *     } from "the-moby-effect/schemas/IPv4.js";
+ *
+ *     const x: IPv4BigintBrand = IPv4BigintBrand(748392749382n);
+ *     assert.strictEqual(x, 748392749382n);
+ *
+ *     const decodeIPv4Bigint = Schema.decodeSync(IPv4Bigint);
+ *     const encodeIPv4Bigint = Schema.encodeSync(IPv4Bigint);
+ *
+ *     assert.deepEqual(decodeIPv4Bigint("1.1.1.1"), {
+ *         family: "ipv4",
+ *         value: 16843009n,
+ *     });
+ *     assert.deepEqual(decodeIPv4Bigint("254.254.254.254"), {
+ *         family: "ipv4",
+ *         value: 4278124286n,
+ *     });
+ *
+ *     assert.strictEqual(
+ *         encodeIPv4Bigint({
+ *             value: IPv4BigintBrand(16843009n),
+ *             family: "ipv4",
+ *         }),
+ *         "1.1.1.1"
+ *     );
+ *     assert.strictEqual(
+ *         encodeIPv4Bigint({
+ *             value: IPv4BigintBrand(4278124286n),
+ *             family: "ipv4",
+ *         }),
+ *         "254.254.254.254"
+ *     );
+ */
+export const IPv4Bigint: $IPv4Bigint = Schema.transformOrFail(
+    IPv4,
+    Schema.Struct({
+        family: IPv4Family,
+        value: Schema.BigIntFromSelf.pipe(Schema.fromBrand(IPv4BigintBrand)),
+    }),
+    {
+        encode: ({ value }) => {
+            const padded = value.toString(16).replace(/:/g, "").padStart(8, "0");
+            const groups: Array<number> = [];
+            for (let i = 0; i < 8; i += 2) {
+                const h = padded.slice(i, i + 2);
+                groups.push(parseInt(h, 16));
+            }
+            return Schema.decode(IPv4)(groups.join(".")).pipe(Effect.mapError(({ issue }) => issue));
+        },
+        decode: ({ ip }) =>
+            Function.pipe(
+                ip,
+                String.split("."),
+                Array.map((s) => Number.parseInt(s, 10)),
+                Array.map((n) => n.toString(16)),
+                Array.map(String.padStart(2, "0")),
+                Array.join(""),
+                (hex) => BigInt(`0x${hex}`),
+                (value) => ({ value, family: "ipv4" }) as const,
+                Effect.succeed
+            ),
+    }
+).annotations({
+    identifier: "IPv4Bigint",
+    description: "An ipv4 address as a bigint",
+});