@typed/id 0.17.1 → 1.0.0-beta.0

package/README.md

@@ -0,0 +1,164 @@
+# @typed/id
+
+> **Beta:** This package is in beta; APIs may change.
+
+`@typed/id` provides **type-safe ID generation** (Effect-based) for multiple formats: **Cuid**, **Ksuid**, **NanoId**, **Ulid**, **Uuid4**, **Uuid5**, **Uuid7**, plus **DateTimes**, **Ids**, and **RandomValues**. Each typically exposes a branded Schema and an Effect that generates the ID (often requiring a service like `RandomValues` or `CuidState`). Use it when you need typed, reproducible IDs in Effect programs.
+
+## Dependencies
+
+- `effect`
+
+## API overview
+
+- **Cuid** — Schema + type; `CuidState` service; Effect to generate Cuid.
+- **Ksuid** — K-sortable unique IDs.
+- **NanoId** — Schema + type + `nanoId` Effect (depends on `RandomValues`).
+- **Ulid** — ULID schema and generation.
+- **Uuid4**, **Uuid5**, **Uuid7** — UUID variants with Schema and generation.
+- **DateTimes** — Date/time helpers used by some ID generators.
+- **Ids** — Generic ID helpers.
+- **RandomValues** — Service for secure random bytes (used by NanoId, etc.).
+
+## Example
+
+```ts
+import { Ids, Uuid5Namespace } from "@typed/id";
+
+const id = yield* Ids.cuid;
+const id = yield* Ids.ksuid;
+const id = yield* Ids.nanoId;
+const id = yield* Ids.ulid;
+const id = yield* Ids.uuid4;
+const id = yield* Ids.uuid5('https://effect.website', Uuid5Namespace.URL);
+const id = yield* Ids.uuid7;
+
+// Provide Ids services
+Effect.provide(Ids.Default)
+Effect.provide(Ids.Test())
+```
+
+## API reference
+
+### Ids
+
+Unified service for generating all ID types. Requires `DateTimes`, `RandomValues`, `CuidState`, and `Uuid7State` (use `Ids.Default` or `Ids.Test()` to provide them).
+
+| Member | Type | Description |
+|--------|------|-------------|
+| `Ids.cuid` | `Effect<Cuid, never, Ids>` | Generate a Cuid. |
+| `Ids.ksuid` | `Effect<Ksuid, never, Ids>` | Generate a Ksuid. |
+| `Ids.nanoId` | `Effect<NanoId, never, Ids>` | Generate a NanoId. |
+| `Ids.ulid` | `Effect<Ulid, never, Ids>` | Generate a ULID. |
+| `Ids.uuid4` | `Effect<Uuid4, never, Ids>` | Generate a UUID v4. |
+| `Ids.uuid5` | `(name, namespace) => Effect<Uuid5, never, Ids>` | Generate a UUID v5 from a name and namespace. Also has `Ids.uuid5.dns`, `.url`, `.oid`, `.x500` taking a single `name`. |
+| `Ids.uuid7` | `Effect<Uuid7, never, Ids>` | Generate a UUID v7. |
+| `Ids.Default` | `Layer<Ids \| DateTimes \| RandomValues>` | Layer that provides `Ids` with default Cuid/Uuid7/DateTimes/RandomValues. |
+| `Ids.Test(options?)` | `Layer<Ids \| DateTimes \| RandomValues>` | Layer for tests; optional `currentTime` and `envData`. |
+
+**TestOptions:** `{ currentTime?: number | string | Date; envData?: string }`
+
+---
+
+### Cuid
+
+| Export | Type | Description |
+|--------|------|-------------|
+| `Cuid` | `Schema<string, Cuid>` | Branded schema for Cuid strings. |
+| `Cuid` (type) | `string` | Branded Cuid type. |
+| `isCuid` | `(value: string) => value is Cuid` | Type guard. |
+| `CuidState` | Service | Provides `next: Effect<CuidSeed>`. Used by `cuid`. |
+| `CuidState.Default` | `Layer<CuidState>` | Default CuidState (uses `"node"` envData). |
+| `cuid` | `Effect<Cuid, never, CuidState>` | Generate a Cuid. |
+
+---
+
+### Ksuid
+
+| Export | Type | Description |
+|--------|------|-------------|
+| `Ksuid` | `Schema<string, Ksuid>` | Branded schema for 27-char base62 Ksuids. |
+| `Ksuid` (type) | `string` | Branded Ksuid type. |
+| `isKsuid` | `(value: string) => value is Ksuid` | Type guard. |
+| `ksuid` | `Effect<Ksuid, never, DateTimes \| RandomValues>` | Generate a Ksuid. |
+
+---
+
+### NanoId
+
+| Export | Type | Description |
+|--------|------|-------------|
+| `NanoId` | `Schema<string, NanoId>` | Branded schema for `[0-9a-zA-Z_-]+` strings. |
+| `NanoId` (type) | `string` | Branded NanoId type. |
+| `isNanoId` | `(value: string) => value is NanoId` | Type guard. |
+| `nanoId` | `Effect<NanoId, never, RandomValues>` | Generate a 21-char NanoId. |
+
+---
+
+### Ulid
+
+| Export | Type | Description |
+|--------|------|-------------|
+| `Ulid` | `Schema<string, Ulid>` | Branded schema for ULID strings. |
+| `Ulid` (type) | `string` | Branded Ulid type. |
+| `isUlid` | `(value: string) => value is Ulid` | Type guard. |
+| `ulid` | `Effect<Ulid, never, DateTimes \| RandomValues>` | Generate a ULID. |
+
+---
+
+### Uuid4
+
+| Export | Type | Description |
+|--------|------|-------------|
+| `Uuid4` | `Schema<string, Uuid4>` | Branded schema for UUID v4. |
+| `Uuid4` (type) | `string` | Branded Uuid4 type. |
+| `isUuid4` | `(value: string) => value is Uuid4` | Type guard. |
+| `uuid4` | `Effect<Uuid4, never, RandomValues>` | Generate a UUID v4. |
+
+---
+
+### Uuid5
+
+| Export | Type | Description |
+|--------|------|-------------|
+| `Uuid5` | `Schema<string, Uuid5>` | Branded schema for UUID v5. |
+| `Uuid5` (type) | `string` | Branded Uuid5 type. |
+| `Uuid5Namespace` | `Uint8Array` (type) + const object | Namespace type; const has `DNS`, `URL`, `OID`, `X500`. |
+| `isUuid5` | `(value: string) => value is Uuid5` | Type guard. |
+| `uuid5` | `(name, namespace) => Effect<Uuid5>` or `(namespace) => (name) => Effect<Uuid5>` | Generate UUID v5 from name + namespace. |
+| `dnsUuid5`, `urlUuid5`, `oidUuid5`, `x500Uuid5` | `(name: string) => Effect<Uuid5>` | Pre-bound effects for standard namespaces. |
+
+---
+
+### Uuid7
+
+| Export | Type | Description |
+|--------|------|-------------|
+| `Uuid7` | `Schema<string, Uuid7>` | Branded schema for UUID v7. |
+| `Uuid7` (type) | `string` | Branded Uuid7 type. |
+| `isUuid7` | `(value: string) => value is Uuid7` | Type guard. |
+| `Uuid7State` | Service | Provides `next: Effect<Uuid7Seed>`. Used by `uuid7`. |
+| `Uuid7State.Default` | `Layer<Uuid7State>` | Default Uuid7State. |
+| `uuid7` | `Effect<Uuid7, never, Uuid7State>` | Generate a UUID v7. |
+
+---
+
+### DateTimes
+
+| Export | Type | Description |
+|--------|------|-------------|
+| `DateTimes` | Service | Provides `now: Effect<number>`, `date: Effect<Date>`. |
+| `DateTimes.now` | `Effect<number, never, DateTimes>` | Current time in ms. |
+| `DateTimes.date` | `Effect<Date, never, DateTimes>` | Current date. |
+| `DateTimes.Default` | `Layer<DateTimes>` | Real clock. |
+| `DateTimes.Fixed(baseDate)` | `Layer<DateTimes>` | Fixed time for tests; `baseDate` is `number \| string \| Date`. |
+
+---
+
+### RandomValues
+
+| Export | Type | Description |
+|--------|------|-------------|
+| `RandomValues` | Service | Provides a function `(length) => Effect<Uint8Array>`. |
+| `RandomValues.call(length)` | `Effect<Uint8Array, never, RandomValues>` | Request `length` cryptographically random bytes. |
+| `RandomValues.Default` | `Layer<RandomValues>` | Uses `crypto.getRandomValues`. |
+| `RandomValues.Random` | `Layer<RandomValues>` | Uses Effect `Random` (e.g. for tests). |

package/dist/Cuid.d.ts

@@ -1,9 +1,10 @@
-import * as Effect from 'effect/Effect';
-import * as Layer from 'effect/Layer';
-import * as Schema from 'effect/Schema';
-import { DateTimes } from './DateTimes.js';
-import { GetRandomValues } from './GetRandomValues.js';
-export declare const Cuid: Schema.brand<Schema.filter<Schema.Schema<string, string, never>>, "@typed/id/CUID">;
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import * as ServiceMap from "effect/ServiceMap";
+import { DateTimes } from "./DateTimes.js";
+import { RandomValues } from "./RandomValues.js";
+export declare const Cuid: Schema.brand<Schema.String, "@typed/id/CUID">;
 export type Cuid = Schema.Schema.Type<typeof Cuid>;
 export declare const isCuid: (value: string) => value is Cuid;
 export type CuidSeed = {
@@ -12,18 +13,28 @@ export type CuidSeed = {
     readonly random: Uint8Array;
     readonly fingerprint: string;
 };
-declare const CuidState_base: import("effect/Context").TagClass<CuidState, "CuidState", {
-    readonly next: Effect.Effect<CuidSeed>;
-}> & Effect.Tag.Proxy<CuidState, {
-    readonly next: Effect.Effect<CuidSeed>;
-}> & {
-    use: <X>(body: (_: {
-        readonly next: Effect.Effect<CuidSeed>;
-    }) => X) => [X] extends [Effect.Effect<infer A, infer E, infer R>] ? Effect.Effect<A, E, R | CuidState> : [X] extends [PromiseLike<infer A_1>] ? Effect.Effect<A_1, import("effect/Cause").UnknownException, CuidState> : Effect.Effect<X, never, CuidState>;
+declare const CuidState_base: ServiceMap.ServiceClass<CuidState, "@typed/id/CuidState", Effect.Effect<{
+    timestamp: number;
+    counter: number;
+    random: Uint8Array<ArrayBufferLike>;
+    fingerprint: string;
+}, never, never>> & {
+    readonly make: (envData: string) => Effect.Effect<Effect.Effect<{
+        timestamp: number;
+        counter: number;
+        random: Uint8Array<ArrayBufferLike>;
+        fingerprint: string;
+    }, never, never>, never, DateTimes | RandomValues>;
 };
 export declare class CuidState extends CuidState_base {
-    static readonly layer: (envData: string) => Layer.Layer<CuidState, never, DateTimes | GetRandomValues>;
-    static readonly Default: Layer.Layer<CuidState, never, DateTimes | GetRandomValues>;
+    static readonly next: Effect.Effect<{
+        timestamp: number;
+        counter: number;
+        random: Uint8Array<ArrayBufferLike>;
+        fingerprint: string;
+    }, never, CuidState>;
+    static readonly Default: Layer.Layer<CuidState | DateTimes | RandomValues, never, never>;
 }
-export declare const makeCuid: Effect.Effect<Cuid, never, DateTimes | GetRandomValues | CuidState>;
+export declare const cuid: Effect.Effect<Cuid, never, CuidState>;
 export {};
+//# sourceMappingURL=Cuid.d.ts.map

package/dist/Cuid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Cuid.d.ts","sourceRoot":"","sources":["../src/Cuid.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,UAAU,MAAM,mBAAmB,CAAC;AAEhD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAQjD,eAAO,MAAM,IAAI,+CAGhB,CAAC;AACF,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC;AAEnD,eAAO,MAAM,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,KAAK,IAAI,IAAsB,CAAC;AAGxE,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;IAC5B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B,CAAC;;;;;;;6BAGgB,MAAM;;;;;;;AADxB,qBAAa,SAAU,SAAQ,cA8B7B;IACA,MAAM,CAAC,QAAQ,CAAC,IAAI;;;;;yBAAwC;IAE5D,MAAM,CAAC,QAAQ,CAAC,OAAO,kEAErB;CACH;AAED,eAAO,MAAM,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,SAAS,CAGtD,CAAC"}

package/dist/Cuid.js

@@ -1,20 +1,50 @@
-import * as Effect from 'effect/Effect';
-import * as Layer from 'effect/Layer';
-import * as Schema from 'effect/Schema';
-import { DateTimes } from './DateTimes.js';
-import { GetRandomValues } from './GetRandomValues.js';
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import * as ServiceMap from "effect/ServiceMap";
+import { sha512 } from "./_sha.js";
+import { DateTimes } from "./DateTimes.js";
+import { RandomValues } from "./RandomValues.js";
 // Constants
 const DEFAULT_LENGTH = 24;
 const BIG_LENGTH = 32;
 const INITIAL_COUNT_MAX = 476782367;
 // Schema
-export const Cuid = Schema.String.pipe(Schema.pattern(/^[a-z][0-9a-z]+$/), Schema.brand('@typed/id/CUID'));
+export const Cuid = Schema.String.pipe(Schema.check(Schema.isPattern(/^[a-z][0-9a-z]+$/)), Schema.brand("@typed/id/CUID"));
 export const isCuid = Schema.is(Cuid);
+export class CuidState extends ServiceMap.Service()("@typed/id/CuidState", {
+    make: (envData) => Effect.gen(function* () {
+        const { now } = yield* DateTimes;
+        const getRandomValues = yield* RandomValues;
+        const initialBytes = yield* getRandomValues(4);
+        const initialValue = Math.abs((initialBytes[0] << 24) |
+            (initialBytes[1] << 16) |
+            (initialBytes[2] << 8) |
+            initialBytes[3]) % INITIAL_COUNT_MAX;
+        // Create fingerprint from environment data
+        const fingerprint = (yield* hash(envData)).substring(0, BIG_LENGTH);
+        let counter = initialValue;
+        return Effect.gen(function* () {
+            const timestamp = yield* now;
+            const random = yield* getRandomValues(32);
+            return {
+                timestamp,
+                counter: counter++,
+                random,
+                fingerprint,
+            };
+        });
+    }),
+}) {
+    static next = Effect.flatten(CuidState.asEffect());
+    static Default = Layer.effect(CuidState, CuidState.make("node")).pipe(Layer.provideMerge([DateTimes.Default, RandomValues.Default]));
+}
+export const cuid = Effect.flatMap(CuidState.next, cuidFromSeed);
 // Utilities
 const ALPHABET = Array.from({ length: 26 }, (_, i) => String.fromCharCode(i + 97));
 const encoder = new TextEncoder();
 function createEntropy(length, random) {
-    let entropy = '';
+    let entropy = "";
     let offset = 0;
     while (entropy.length < length) {
         const value = random[offset];
@@ -24,10 +54,7 @@ function createEntropy(length, random) {
     return entropy;
 }
 function hash(input) {
-    // Convert string to bytes
-    const data = encoder.encode(input);
-    // Create a hash using the Web Crypto API
-    return crypto.subtle.digest('SHA-512', data).then((buffer) => {
+    return Effect.map(sha512(encoder.encode(input)), (buffer) => {
         const view = new Uint8Array(buffer);
         let value = 0n;
         for (const byte of view) {
@@ -37,36 +64,7 @@ function hash(input) {
         return value.toString(36).slice(1);
     });
 }
-// State Management
-export class CuidState extends Effect.Tag('CuidState')() {
-    static layer = (envData) => Layer.effect(this, Effect.gen(function* () {
-        const { now } = yield* DateTimes;
-        const getRandomValues = yield* GetRandomValues;
-        const initialBytes = yield* getRandomValues(4);
-        const initialValue = Math.abs((initialBytes[0] << 24) |
-            (initialBytes[1] << 16) |
-            (initialBytes[2] << 8) |
-            initialBytes[3]) % INITIAL_COUNT_MAX;
-        // Create fingerprint from environment data
-        const fingerprint = yield* Effect.promise(() => hash(envData).then((h) => h.substring(0, BIG_LENGTH)));
-        let counter = initialValue;
-        return {
-            next: Effect.gen(function* () {
-                const timestamp = yield* now;
-                const random = yield* getRandomValues(32);
-                return {
-                    timestamp,
-                    counter: counter++,
-                    random,
-                    fingerprint,
-                };
-            }),
-        };
-    }));
-    static Default = this.layer('node');
-}
-// Core Functions
-function cuidFromSeed({ timestamp, counter, random, fingerprint }) {
+function cuidFromSeed({ counter, fingerprint, random, timestamp }) {
     return Effect.gen(function* () {
         // First letter is always a random lowercase letter from the seed
         const firstLetter = ALPHABET[random[0] % ALPHABET.length];
@@ -77,12 +75,9 @@ function cuidFromSeed({ timestamp, counter, random, fingerprint }) {
         const salt = createEntropy(4, random.slice(1));
         // Hash all components together
         const hashInput = `${time}${salt}${count}${fingerprint}`;
-        const hashed = yield* Effect.promise(() => hash(hashInput));
+        const hashed = yield* hash(hashInput);
         // Construct the final CUID
         const id = `${firstLetter}${hashed.substring(0, DEFAULT_LENGTH - 1)}`;
-        return Cuid.make(id);
+        return Cuid.makeUnsafe(id);
     });
 }
-// Public API
-export const makeCuid = Effect.flatMap(CuidState.next, cuidFromSeed);
-//# sourceMappingURL=Cuid.js.map

package/dist/DateTimes.d.ts

@@ -1,20 +1,20 @@
-import * as Effect from 'effect/Effect';
-import * as Layer from 'effect/Layer';
-declare const DateTimes_base: import("effect/Context").TagClass<DateTimes, "DateTimes", {
-    readonly now: Effect.Effect<number>;
-    readonly date: Effect.Effect<Date>;
-}> & Effect.Tag.Proxy<DateTimes, {
-    readonly now: Effect.Effect<number>;
-    readonly date: Effect.Effect<Date>;
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as ServiceMap from "effect/ServiceMap";
+declare const DateTimes_base: ServiceMap.ServiceClass<DateTimes, "@typed/id/DateTimes", {
+    now: Effect.Effect<number, never, never>;
+    date: Effect.Effect<Date, never, never>;
 }> & {
-    use: <X>(body: (_: {
-        readonly now: Effect.Effect<number>;
-        readonly date: Effect.Effect<Date>;
-    }) => X) => [X] extends [Effect.Effect<infer A, infer E, infer R>] ? Effect.Effect<A, E, DateTimes | R> : [X] extends [PromiseLike<infer A_1>] ? Effect.Effect<A_1, import("effect/Cause").UnknownException, DateTimes> : Effect.Effect<X, never, DateTimes>;
+    readonly make: Effect.Effect<{
+        now: Effect.Effect<number, never, never>;
+        date: Effect.Effect<Date, never, never>;
+    }, never, never>;
 };
 export declare class DateTimes extends DateTimes_base {
-    static readonly make: (now: Effect.Effect<number>) => Layer.Layer<DateTimes>;
-    static readonly Default: Layer.Layer<DateTimes>;
-    static readonly Fixed: (base: Date) => Layer.Layer<DateTimes>;
+    static readonly now: Effect.Effect<number, never, DateTimes>;
+    static readonly date: Effect.Effect<Date, never, DateTimes>;
+    static readonly Default: Layer.Layer<DateTimes, never, never>;
+    static readonly Fixed: (baseDate: number | string | Date) => Layer.Layer<DateTimes, never, never>;
 }
 export {};
+//# sourceMappingURL=DateTimes.d.ts.map

package/dist/DateTimes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DateTimes.d.ts","sourceRoot":"","sources":["../src/DateTimes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,KAAK,UAAU,MAAM,mBAAmB,CAAC;;;;;;;;;;AAEhD,qBAAa,SAAU,SAAQ,cAK7B;IACA,MAAM,CAAC,QAAQ,CAAC,GAAG,0CAA0D;IAC7E,MAAM,CAAC,QAAQ,CAAC,IAAI,wCAA4D;IAEhF,MAAM,CAAC,QAAQ,CAAC,OAAO,uCAA2C;IAElE,MAAM,CAAC,QAAQ,CAAC,KAAK,GAAI,UAAU,MAAM,GAAG,MAAM,GAAG,IAAI,0CAkBrD;CACL"}

package/dist/DateTimes.js

@@ -1,22 +1,25 @@
-import * as Effect from 'effect/Effect';
-import * as Layer from 'effect/Layer';
-export class DateTimes extends Effect.Tag('DateTimes')() {
-    static make = (now) => Layer.succeed(this, {
-        now,
-        date: now.pipe(Effect.map((millis) => new Date(millis))),
-    });
-    static Default = this.make(Effect.clockWith((clock) => clock.currentTimeMillis));
-    static Fixed = (base) => Layer.effect(DateTimes, Effect.gen(function* () {
-        const clock = yield* Effect.clock;
+import * as Clock from "effect/Clock";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as ServiceMap from "effect/ServiceMap";
+export class DateTimes extends ServiceMap.Service()("@typed/id/DateTimes", {
+    make: Effect.succeed({
+        now: Effect.sync(() => Date.now()),
+        date: Effect.sync(() => new Date()),
+    }),
+}) {
+    static now = Effect.flatMap(DateTimes.asEffect(), ({ now }) => now);
+    static date = Effect.flatMap(DateTimes.asEffect(), ({ date }) => date);
+    static Default = Layer.effect(DateTimes, DateTimes.make);
+    static Fixed = (baseDate) => Layer.effect(DateTimes, Effect.gen(function* () {
+        const clock = yield* Clock.Clock;
+        const base = new Date(baseDate);
         const baseN = BigInt(base.getTime());
         const startMillis = yield* clock.currentTimeMillis;
         const now = clock.currentTimeMillis.pipe(Effect.map((millis) => 
         // Use BigInt to avoid floating point precision issues which can break deterministic testing
         Number(baseN + BigInt(millis) - BigInt(startMillis))));
-        return {
-            now,
-            date: now.pipe(Effect.map((millis) => new Date(millis))),
-        };
+        const date = now.pipe(Effect.map((millis) => new Date(millis)));
+        return DateTimes.of({ now, date });
     }));
 }
-//# sourceMappingURL=DateTimes.js.map

package/dist/Id.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Id.test.d.ts.map

package/dist/Id.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Id.test.d.ts","sourceRoot":"","sources":["../src/Id.test.ts"],"names":[],"mappings":""}

package/dist/Id.test.js

@@ -0,0 +1,190 @@
+import * as Effect from "effect/Effect";
+import { describe, expect, it } from "vitest";
+import * as Cuid from "./Cuid.js";
+import { Ids } from "./Ids.js";
+import * as Ksuid from "./Ksuid.js";
+import * as NanoId from "./NanoId.js";
+import * as Ulid from "./Ulid.js";
+import * as Uuid4 from "./Uuid4.js";
+import * as Uuid5 from "./Uuid5.js";
+import * as Uuid7 from "./Uuid7.js";
+const run = (effect) => Effect.runPromise(Effect.provide(effect, Ids.Test()));
+describe("@typed/id", () => {
+    describe("type guards", () => {
+        describe("isUuid4", () => {
+            it("accepts valid UUID v4", () => {
+                expect(Uuid4.isUuid4("f47ac10b-58cc-4372-a567-0e02b2c3d479")).toBe(true);
+                expect(Uuid4.isUuid4("550e8400-e29b-41d4-a716-446655440000")).toBe(true);
+            });
+            it("rejects invalid formats", () => {
+                expect(Uuid4.isUuid4("")).toBe(false);
+                expect(Uuid4.isUuid4("not-a-uuid")).toBe(false);
+                expect(Uuid4.isUuid4("f47ac10b-58cc-4372-a567-0e02b2c3d479".replace(/-/g, ""))).toBe(false);
+                expect(Uuid4.isUuid4("g47ac10b-58cc-4372-a567-0e02b2c3d479")).toBe(false); // invalid hex
+            });
+            it("rejects UUID v5 as UUID v4", () => {
+                expect(Uuid4.isUuid4("886313e1-3b8a-5372-9b90-0c9aee199e5d")).toBe(false);
+            });
+        });
+        describe("isUuid5", () => {
+            it("accepts valid UUID v5", () => {
+                expect(Uuid5.isUuid5("886313e1-3b8a-5372-9b90-0c9aee199e5d")).toBe(true);
+                expect(Uuid5.isUuid5("c2ee5f2e-5b2e-5f2e-8b2e-5b2e5f2e8b2e")).toBe(true);
+            });
+            it("rejects invalid formats", () => {
+                expect(Uuid5.isUuid5("")).toBe(false);
+                expect(Uuid5.isUuid5("f47ac10b-58cc-4372-a567-0e02b2c3d479")).toBe(false); // v4
+            });
+        });
+        describe("isUuid7", () => {
+            it("accepts valid UUID v7", () => {
+                expect(Uuid7.isUuid7("018eebb4-1f2c-7c3a-8b4d-123456789abc")).toBe(true);
+            });
+            it("rejects invalid formats", () => {
+                expect(Uuid7.isUuid7("")).toBe(false);
+                expect(Uuid7.isUuid7("f47ac10b-58cc-4372-a567-0e02b2c3d479")).toBe(false); // v4
+            });
+        });
+        describe("isCuid", () => {
+            it("accepts valid CUID-like strings (lowercase letter + base36)", () => {
+                expect(Cuid.isCuid("c1234567890abcdefghijklmn")).toBe(true);
+                expect(Cuid.isCuid("a0")).toBe(true);
+            });
+            it("rejects invalid formats", () => {
+                expect(Cuid.isCuid("")).toBe(false);
+                expect(Cuid.isCuid("A123")).toBe(false); // must start with lowercase
+                expect(Cuid.isCuid("1abc")).toBe(false); // must start with letter
+                expect(Cuid.isCuid("c123-456")).toBe(false); // no hyphen
+            });
+        });
+        describe("isKsuid", () => {
+            it("accepts 27-char base62 strings", () => {
+                expect(Ksuid.isKsuid("0ujsszwN8NRYtYaMBZrYCVp4O1")).toBe(true);
+                expect(Ksuid.isKsuid("0123456789ABCDEFGHIJKLMNOP")).toBe(true);
+            });
+            it("rejects invalid formats", () => {
+                expect(Ksuid.isKsuid("")).toBe(false);
+                expect(Ksuid.isKsuid("short")).toBe(false);
+                expect(Ksuid.isKsuid("0ujsszwN8NRYtYaMBZrYCVp4O1!")).toBe(false); // 28 chars, invalid char
+            });
+        });
+        describe("isNanoId", () => {
+            it("accepts strings with only 0-9a-zA-Z_-", () => {
+                expect(NanoId.isNanoId("V1StGXR8_Z5jdHi6B-myT")).toBe(true);
+                expect(NanoId.isNanoId("abc123")).toBe(true);
+                expect(NanoId.isNanoId("_-_")).toBe(true);
+            });
+            it("rejects invalid characters", () => {
+                expect(NanoId.isNanoId("")).toBe(false);
+                expect(NanoId.isNanoId("space in id")).toBe(false);
+                expect(NanoId.isNanoId("dot.id")).toBe(false);
+            });
+        });
+        describe("isUlid", () => {
+            it("accepts valid ULIDs", () => {
+                expect(Ulid.isUlid("01ARZ3NDEKTSV4RRFFQ69G5FAV")).toBe(true);
+                expect(Ulid.isUlid("0123456789ABCDEFGHJKMNPQR")).toBe(true);
+            });
+            it("rejects invalid formats", () => {
+                expect(Ulid.isUlid("")).toBe(false);
+                expect(Ulid.isUlid("01ARZ3NDEKTSV4RRFFQ69G5FA")).toBe(false); // wrong length
+                expect(Ulid.isUlid("01ARZ3NDEKTSV4RRFFQ69G5FAV0")).toBe(false); // wrong length
+                expect(Ulid.isUlid("01ARZ3NDEKTSV4RRFFQ69G5FAI")).toBe(false); // I not in Crockford base32
+            });
+        });
+    });
+    describe("Ids service", () => {
+        it("uuid4 produces valid UUID v4", async () => {
+            const id = await run(Ids.uuid4);
+            expect(id).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
+            expect(Uuid4.isUuid4(id)).toBe(true);
+        });
+        it("uuid5 produces valid UUID v5", async () => {
+            const id = await run(Ids.uuid5("hello", Uuid5.Uuid5Namespace.DNS));
+            expect(id).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
+            expect(Uuid5.isUuid5(id)).toBe(true);
+        });
+        it("uuid5 is deterministic for same name and namespace", async () => {
+            const a = await run(Ids.uuid5("test", Uuid5.Uuid5Namespace.URL));
+            const b = await run(Ids.uuid5("test", Uuid5.Uuid5Namespace.URL));
+            expect(a).toBe(b);
+        });
+        it("uuid5 differs for different names", async () => {
+            const a = await run(Ids.uuid5("a", Uuid5.Uuid5Namespace.DNS));
+            const b = await run(Ids.uuid5("b", Uuid5.Uuid5Namespace.DNS));
+            expect(a).not.toBe(b);
+        });
+        it("uuid5 predefined namespaces work", async () => {
+            const dns = await run(Ids.uuid5.dns("example.com"));
+            const url = await run(Ids.uuid5.url("https://example.com"));
+            const oid = await run(Ids.uuid5.oid("1.2.3"));
+            const x500 = await run(Ids.uuid5.x500("cn=test"));
+            expect(Uuid5.isUuid5(dns)).toBe(true);
+            expect(Uuid5.isUuid5(url)).toBe(true);
+            expect(Uuid5.isUuid5(oid)).toBe(true);
+            expect(Uuid5.isUuid5(x500)).toBe(true);
+            expect(new Set([dns, url, oid, x500]).size).toBe(4);
+        });
+        it("uuid7 produces valid UUID v7", async () => {
+            const id = await run(Ids.uuid7);
+            expect(id).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
+            expect(Uuid7.isUuid7(id)).toBe(true);
+        });
+        it("cuid produces valid CUID", async () => {
+            const id = await run(Ids.cuid);
+            expect(Cuid.isCuid(id)).toBe(true);
+            expect(id).toMatch(/^[a-z][0-9a-z]+$/);
+        });
+        it("ksuid produces valid KSUID", async () => {
+            const id = await run(Ids.ksuid);
+            expect(Ksuid.isKsuid(id)).toBe(true);
+            expect(id).toHaveLength(27);
+            expect(id).toMatch(/^[0-9a-zA-Z]{27}$/);
+        });
+        it("nanoId produces valid NanoId", async () => {
+            const id = await run(Ids.nanoId);
+            expect(NanoId.isNanoId(id)).toBe(true);
+            expect(id).toMatch(/^[0-9a-zA-Z_-]+$/);
+            expect(id).toHaveLength(21);
+        });
+        it("ulid produces valid ULID", async () => {
+            const id = await run(Ids.ulid);
+            expect(Ulid.isUlid(id)).toBe(true);
+            expect(id).toHaveLength(26);
+            expect(id).toMatch(/^[0-9A-HJKMNP-TV-Z]{26}$/);
+        });
+        it("Ids.Test with fixed time yields deterministic time-based prefixes", async () => {
+            const fixedTime = new Date("2025-01-15T12:00:00Z").getTime();
+            const runFixed = (effect) => Effect.runPromise(Effect.provide(effect, Ids.Test({ currentTime: fixedTime })));
+            const ulid1 = await runFixed(Ids.ulid);
+            const ulid2 = await runFixed(Ids.ulid);
+            const ksuid1 = await runFixed(Ids.ksuid);
+            const ksuid2 = await runFixed(Ids.ksuid);
+            expect(ulid1.slice(0, 10)).toBe(ulid2.slice(0, 10));
+            expect(ksuid1.slice(0, 5)).toBe(ksuid2.slice(0, 5));
+        });
+    });
+    describe("Ids.Default", () => {
+        it("runs all generators with default layer", async () => {
+            const program = Effect.gen(function* () {
+                const ids = yield* Ids;
+                const u4 = yield* ids.uuid4;
+                const u5 = yield* ids.uuid5("default-test", Uuid5.Uuid5Namespace.DNS);
+                const u7 = yield* ids.uuid7;
+                const c = yield* ids.cuid;
+                const k = yield* ids.ksuid;
+                const n = yield* ids.nanoId;
+                const u = yield* ids.ulid;
+                return { u4, u5, u7, c, k, n, u };
+            });
+            const result = await Effect.runPromise(Effect.provide(program, Ids.Default));
+            expect(Uuid4.isUuid4(result.u4)).toBe(true);
+            expect(Uuid5.isUuid5(result.u5)).toBe(true);
+            expect(Uuid7.isUuid7(result.u7)).toBe(true);
+            expect(Cuid.isCuid(result.c)).toBe(true);
+            expect(Ksuid.isKsuid(result.k)).toBe(true);
+            expect(NanoId.isNanoId(result.n)).toBe(true);
+            expect(Ulid.isUlid(result.u)).toBe(true);
+        });
+    });
+});