@go-mondo/identity-sdk 0.0.2-beta.1 → 0.0.2-beta.13

package/dist/esm/common/schema/collection.d.ts

@@ -1,17 +1,18 @@
+import { z } from 'zod';
 import { type Pagination } from './pagination.js';
-export declare const CollectionSchema: import("arktype").Generic<[["t", unknown]], {
-    readonly items: "t[]";
-}, {}, {}>;
+export declare const CollectionSchema: <T extends z.ZodTypeAny>(itemSchema: T) => z.ZodObject<{
+    items: z.ZodArray<T>;
+}, z.core.$strip>;
 export type Collection<I> = {
     items: I[];
 };
-export declare const PaginationCollectionSchema: import("arktype").Generic<[["t", unknown]], {
-    readonly items: "t[]";
-    readonly pagination: [import("arktype/internal/methods/object.ts").ObjectType<{
-        pageSize?: string | number | undefined;
-        nextToken?: string | undefined;
-    }, {}>, "?"];
-}, {}, {}>;
+export declare const PaginationCollectionSchema: <T extends z.ZodTypeAny>(itemSchema: T) => z.ZodObject<{
+    items: z.ZodArray<T>;
+    pagination: z.ZodOptional<z.ZodObject<{
+        pageSize: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>>;
+        nextToken: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNull]>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export type PaginationCollection<I> = Collection<I> & {
     pagination?: Pagination;
 };

package/dist/esm/common/schema/collection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/collection.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,UAAU,EAAoB,MAAM,iBAAiB,CAAC;AAEpE,eAAO,MAAM,gBAAgB;;UAAgC,CAAC;AAC9D,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI;IAC1B,KAAK,EAAE,CAAC,EAAE,CAAC;CACZ,CAAC;AAEF,eAAO,MAAM,0BAA0B;;;;;;UAGrC,CAAC;AACH,MAAM,MAAM,oBAAoB,CAAC,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,GAAG;IACpD,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB,CAAC"}
+{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/collection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,KAAK,UAAU,EAAoB,MAAM,iBAAiB,CAAC;AAEpE,eAAO,MAAM,gBAAgB,GAAI,CAAC,SAAS,CAAC,CAAC,UAAU,EAAE,YAAY,CAAC;;iBAC5B,CAAC;AAC3C,MAAM,MAAM,UAAU,CAAC,CAAC,IAAI;IAC1B,KAAK,EAAE,CAAC,EAAE,CAAC;CACZ,CAAC;AAEF,eAAO,MAAM,0BAA0B,GAAI,CAAC,SAAS,CAAC,CAAC,UAAU,EAC/D,YAAY,CAAC;;;;;;iBAKX,CAAC;AACL,MAAM,MAAM,oBAAoB,CAAC,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,GAAG;IACpD,UAAU,CAAC,EAAE,UAAU,CAAC;CACzB,CAAC"}

package/dist/esm/common/schema/collection.js

@@ -1,7 +1,7 @@
-import { type } from 'arktype';
+import { z } from 'zod';
 import { PaginationSchema } from './pagination.js';
-export const CollectionSchema = type('<t>', { items: 't[]' });
-export const PaginationCollectionSchema = type('<t>', {
-    items: 't[]',
+export const CollectionSchema = (itemSchema) => z.object({ items: z.array(itemSchema) });
+export const PaginationCollectionSchema = (itemSchema) => z.object({
+    items: z.array(itemSchema),
     pagination: PaginationSchema.optional(),
 });

package/dist/esm/common/schema/collection.test.d.ts

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

package/dist/esm/common/schema/collection.test.d.ts.map

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

package/dist/esm/common/schema/collection.test.js

@@ -0,0 +1,114 @@
+import { describe, expect, test } from 'vitest';
+import { z } from 'zod';
+import { CollectionSchema, PaginationCollectionSchema } from './collection.js';
+describe('Common Schema - Collection', () => {
+    describe('CollectionSchema', () => {
+        test('should accept valid collection with string items', () => {
+            const StringCollectionSchema = CollectionSchema(z.string());
+            const result = StringCollectionSchema.safeParse({
+                items: ['item1', 'item2', 'item3'],
+            });
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toEqual({
+                    items: ['item1', 'item2', 'item3'],
+                });
+            }
+        });
+        test('should accept valid collection with number items', () => {
+            const NumberCollectionSchema = CollectionSchema(z.number());
+            const result = NumberCollectionSchema.safeParse({
+                items: [1, 2, 3],
+            });
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toEqual({
+                    items: [1, 2, 3],
+                });
+            }
+        });
+        test('should accept empty collection', () => {
+            const StringCollectionSchema = CollectionSchema(z.string());
+            const result = StringCollectionSchema.safeParse({
+                items: [],
+            });
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toEqual({
+                    items: [],
+                });
+            }
+        });
+        test('should reject invalid items type', () => {
+            const StringCollectionSchema = CollectionSchema(z.string());
+            const result = StringCollectionSchema.safeParse({
+                items: 'not-an-array',
+            });
+            expect(result.success).toBe(false);
+        });
+    });
+    describe('PaginationCollectionSchema', () => {
+        test('should accept valid paginated collection', () => {
+            const StringPaginationCollectionSchema = PaginationCollectionSchema(z.string());
+            const result = StringPaginationCollectionSchema.safeParse({
+                items: ['item1', 'item2'],
+                pagination: {
+                    pageSize: '10',
+                    nextToken: 'token123',
+                },
+            });
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toEqual({
+                    items: ['item1', 'item2'],
+                    pagination: {
+                        pageSize: '10',
+                        nextToken: 'token123',
+                    },
+                });
+            }
+        });
+        test('should accept collection without pagination', () => {
+            const StringPaginationCollectionSchema = PaginationCollectionSchema(z.string());
+            const result = StringPaginationCollectionSchema.safeParse({
+                items: ['item1', 'item2'],
+            });
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toEqual({
+                    items: ['item1', 'item2'],
+                });
+            }
+        });
+        test('should accept collection with empty pagination', () => {
+            const StringPaginationCollectionSchema = PaginationCollectionSchema(z.string());
+            const result = StringPaginationCollectionSchema.safeParse({
+                items: ['item1'],
+                pagination: {},
+            });
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toEqual({
+                    items: ['item1'],
+                    pagination: {},
+                });
+            }
+        });
+        test('should reject invalid pagination', () => {
+            const StringPaginationCollectionSchema = PaginationCollectionSchema(z.string());
+            const result = StringPaginationCollectionSchema.safeParse({
+                items: ['item1'],
+                pagination: {
+                    pageSize: true,
+                },
+            });
+            expect(result.success).toBe(false);
+        });
+    });
+});

package/dist/esm/common/schema/dates.d.ts

@@ -1,39 +1,40 @@
-export declare const RequiredDateSchema: import("arktype/internal/methods/object.ts").ObjectType<Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>), {}>;
-export declare const OptionalDateSchema: import("arktype/internal/methods/base.ts").BaseType<Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined, {}>;
-export type AnyRequiredDateType = typeof RequiredDateSchema.inferIn;
-export type RequiredDate = typeof RequiredDateSchema.inferOut;
-export type AnyOptionalDate = typeof OptionalDateSchema.inferIn;
-export type OptionalDate = typeof OptionalDateSchema.inferOut;
-export declare const RequiredDatePayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<(In: string | Date) => import("arktype/internal/attributes.ts").Out<string>, {}>;
-export declare const OptionalDatePayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<(In: string | Date | undefined) => import("arktype/internal/attributes.ts").Out<string | undefined>, {}>;
-export type RequiredDatePayload = typeof RequiredDatePayloadSchema.inferOut;
-export type OptionalDatePayload = typeof OptionalDatePayloadSchema.inferOut;
+import { z } from 'zod';
+export declare const RequiredDateSchema: z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>;
+export declare const OptionalDateSchema: z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>;
+export type AnyRequiredDateType = z.input<typeof RequiredDateSchema>;
+export type RequiredDate = z.output<typeof RequiredDateSchema>;
+export type AnyOptionalDate = z.input<typeof OptionalDateSchema>;
+export type OptionalDate = z.output<typeof OptionalDateSchema>;
+export declare const RequiredDatePayloadSchema: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+export declare const OptionalDatePayloadSchema: z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>, z.ZodTransform<string | undefined, Date | undefined>>;
+export type RequiredDatePayload = z.output<typeof RequiredDatePayloadSchema>;
+export type OptionalDatePayload = z.output<typeof OptionalDatePayloadSchema>;
 /**
  * Created At
  */
-export declare const CreatedAtPropertyPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    createdAt: (In: string | Date) => import("arktype/internal/attributes.ts").Out<string>;
-}, {}>;
-export type CreatedAtPropertyPayload = typeof CreatedAtPropertyPayloadSchema.inferOut;
+export declare const CreatedAtPropertyPayloadSchema: z.ZodObject<{
+    createdAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+}, z.core.$strip>;
+export type CreatedAtPropertyPayload = z.output<typeof CreatedAtPropertyPayloadSchema>;
 /**
  * Updated At
  */
-export declare const UpdatedAtPropertyPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    updatedAt: (In: string | Date) => import("arktype/internal/attributes.ts").Out<string>;
-}, {}>;
-export type UpdatedAtPropertyPayload = typeof UpdatedAtPropertyPayloadSchema.inferOut;
+export declare const UpdatedAtPropertyPayloadSchema: z.ZodObject<{
+    updatedAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+}, z.core.$strip>;
+export type UpdatedAtPropertyPayload = z.output<typeof UpdatedAtPropertyPayloadSchema>;
 /**
  * Deleted At
  */
-export declare const DeletedAtPropertyPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    deletedAt?: ((In: string | Date | undefined) => import("arktype/internal/attributes.ts").Out<string | undefined>) | undefined;
-}, {}>;
-export type DeletedAtPropertyPayload = typeof DeletedAtPropertyPayloadSchema.inferOut;
+export declare const DeletedAtPropertyPayloadSchema: z.ZodObject<{
+    deletedAt: z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>, z.ZodTransform<string | undefined, Date | undefined>>;
+}, z.core.$strip>;
+export type DeletedAtPropertyPayload = z.output<typeof DeletedAtPropertyPayloadSchema>;
 /**
  * Deactivated At
  */
-export declare const DeactivatedAtPropertyPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    deactivatedAt?: ((In: string | Date | undefined) => import("arktype/internal/attributes.ts").Out<string | undefined>) | undefined;
-}, {}>;
-export type DeactivatedAtPropertyPayload = typeof DeactivatedAtPropertyPayloadSchema.inferOut;
+export declare const DeactivatedAtPropertyPayloadSchema: z.ZodObject<{
+    deactivatedAt: z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>, z.ZodTransform<string | undefined, Date | undefined>>;
+}, z.core.$strip>;
+export type DeactivatedAtPropertyPayload = z.output<typeof DeactivatedAtPropertyPayloadSchema>;
 //# sourceMappingURL=dates.d.ts.map

package/dist/esm/common/schema/dates.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dates.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/dates.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,kBAAkB,yIAA2C,CAAC;AAC3E,eAAO,MAAM,kBAAkB,iJAAqC,CAAC;AAErE,MAAM,MAAM,mBAAmB,GAAG,OAAO,kBAAkB,CAAC,OAAO,CAAC;AACpE,MAAM,MAAM,YAAY,GAAG,OAAO,kBAAkB,CAAC,QAAQ,CAAC;AAE9D,MAAM,MAAM,eAAe,GAAG,OAAO,kBAAkB,CAAC,OAAO,CAAC;AAChE,MAAM,MAAM,YAAY,GAAG,OAAO,kBAAkB,CAAC,QAAQ,CAAC;AAG9D,eAAO,MAAM,yBAAyB,0IAErC,CAAC;AACF,eAAO,MAAM,yBAAyB,kKAErC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,OAAO,yBAAyB,CAAC,QAAQ,CAAC;AAC5E,MAAM,MAAM,mBAAmB,GAAG,OAAO,yBAAyB,CAAC,QAAQ,CAAC;AAE5E;;GAEG;AACH,eAAO,MAAM,8BAA8B;;MAEzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAClC,OAAO,8BAA8B,CAAC,QAAQ,CAAC;AAEjD;;GAEG;AACH,eAAO,MAAM,8BAA8B;;MAEzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAClC,OAAO,8BAA8B,CAAC,QAAQ,CAAC;AAEjD;;GAEG;AACH,eAAO,MAAM,8BAA8B;;MAEzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAClC,OAAO,8BAA8B,CAAC,QAAQ,CAAC;AAEjD;;GAEG;AACH,eAAO,MAAM,kCAAkC;;MAE7C,CAAC;AACH,MAAM,MAAM,4BAA4B,GACtC,OAAO,kCAAkC,CAAC,QAAQ,CAAC"}
+{"version":3,"file":"dates.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/dates.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,kBAAkB,wFAM7B,CAAC;AACH,eAAO,MAAM,kBAAkB,uGAAgC,CAAC;AAEhE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AACrE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE/D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AACjE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAG/D,eAAO,MAAM,yBAAyB,iIAErC,CAAC;AACF,eAAO,MAAM,yBAAyB,wKAErC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAC7E,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE7E;;GAEG;AACH,eAAO,MAAM,8BAA8B;;iBAEzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAC7C,OAAO,8BAA8B,CACtC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,8BAA8B;;iBAEzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAC7C,OAAO,8BAA8B,CACtC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,8BAA8B;;iBAEzC,CAAC;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAC7C,OAAO,8BAA8B,CACtC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kCAAkC;;iBAE7C,CAAC;AACH,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,MAAM,CACjD,OAAO,kCAAkC,CAC1C,CAAC"}

package/dist/esm/common/schema/dates.js

@@ -1,31 +1,37 @@
-import { type } from 'arktype';
+import { z } from 'zod';
 // Normalizing to a Date object
-export const RequiredDateSchema = type('Date').or('string.date.iso.parse');
-export const OptionalDateSchema = RequiredDateSchema.or('undefined');
+export const RequiredDateSchema = z.union([
+    z.date(),
+    z
+        .string()
+        .datetime()
+        .transform((str) => new Date(str)),
+]);
+export const OptionalDateSchema = RequiredDateSchema.optional();
 // What the class property is serialized to
-export const RequiredDatePayloadSchema = RequiredDateSchema.pipe.try((d) => d.toISOString());
-export const OptionalDatePayloadSchema = OptionalDateSchema.pipe.try((d) => d?.toISOString());
+export const RequiredDatePayloadSchema = RequiredDateSchema.transform((d) => d.toISOString());
+export const OptionalDatePayloadSchema = OptionalDateSchema.transform((d) => d?.toISOString());
 /**
  * Created At
  */
-export const CreatedAtPropertyPayloadSchema = type({
+export const CreatedAtPropertyPayloadSchema = z.object({
     createdAt: RequiredDatePayloadSchema,
 });
 /**
  * Updated At
  */
-export const UpdatedAtPropertyPayloadSchema = type({
+export const UpdatedAtPropertyPayloadSchema = z.object({
     updatedAt: RequiredDatePayloadSchema,
 });
 /**
  * Deleted At
  */
-export const DeletedAtPropertyPayloadSchema = type({
-    'deletedAt?': OptionalDatePayloadSchema,
+export const DeletedAtPropertyPayloadSchema = z.object({
+    deletedAt: OptionalDatePayloadSchema,
 });
 /**
  * Deactivated At
  */
-export const DeactivatedAtPropertyPayloadSchema = type({
-    'deactivatedAt?': OptionalDatePayloadSchema,
+export const DeactivatedAtPropertyPayloadSchema = z.object({
+    deactivatedAt: OptionalDatePayloadSchema,
 });

package/dist/esm/common/schema/dates.test.js

@@ -1,31 +1,42 @@
-import { type } from 'arktype';
 import { describe, expect, test } from 'vitest';
 import { RequiredDatePayloadSchema, RequiredDateSchema } from './dates.js';
 describe('Common - Dates', () => {
     describe('Date Schema', () => {
         test('should accept an iso string', async () => {
-            const result = RequiredDateSchema(new Date().toISOString());
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toBeInstanceOf(Date);
+            const result = RequiredDateSchema.safeParse(new Date().toISOString());
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toBeInstanceOf(Date);
+            }
         });
         test('should accept a Date object', async () => {
-            const result = RequiredDateSchema(new Date());
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).toBeInstanceOf(Date);
+            const result = RequiredDateSchema.safeParse(new Date());
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toBeInstanceOf(Date);
+            }
         });
     });
     describe('Payload Schema', () => {
         test('should parse a Date to an ISO string', async () => {
             const iso = new Date().toISOString();
-            const result = RequiredDatePayloadSchema(new Date(iso));
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).to.equal(iso);
+            const result = RequiredDatePayloadSchema.safeParse(new Date(iso));
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toBe(iso);
+            }
         });
         test('should parse an ISO to an ISO string', async () => {
             const iso = new Date().toISOString();
-            const result = RequiredDatePayloadSchema(iso);
-            expect(result).not.toBeInstanceOf(type.errors);
-            expect(result).to.equal(iso);
+            const result = RequiredDatePayloadSchema.safeParse(iso);
+            // Parse succeeds for valid data
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toBe(iso);
+            }
         });
     });
 });

package/dist/esm/common/schema/id.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+export declare const KSUIDSchema: (prefix: string) => z.ZodString;
+//# sourceMappingURL=id.d.ts.map

package/dist/esm/common/schema/id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"id.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/id.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,WAAW,GAAI,QAAQ,MAAM,gBACmB,CAAC"}

package/dist/esm/common/schema/id.js

@@ -0,0 +1,2 @@
+import { z } from 'zod';
+export const KSUIDSchema = (prefix) => z.string().regex(new RegExp(`^${prefix}_[A-Za-z0-9]{27}$`));

package/dist/esm/common/schema/id.test.d.ts

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

package/dist/esm/common/schema/id.test.d.ts.map

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

package/dist/esm/common/schema/id.test.js

@@ -0,0 +1,146 @@
+import { describe, expect, test } from 'vitest';
+import { KSUIDSchema } from './id.js';
+describe('Common Schema - ID', () => {
+    describe('KSUIDSchema', () => {
+        test('should accept valid KSUID with correct prefix', () => {
+            const schema = KSUIDSchema('usr');
+            const validId = 'usr_123456789012345678901234567';
+            const result = schema.safeParse(validId);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toBe(validId);
+            }
+        });
+        test('should accept KSUID with different prefixes', () => {
+            const userSchema = KSUIDSchema('usr');
+            const appSchema = KSUIDSchema('app');
+            const activitySchema = KSUIDSchema('act');
+            const userId = 'usr_abcdefghijklmnopqrstuvwxy12';
+            const appId = 'app_1234567890ABCDEFGHIJKLMNOP1';
+            const activityId = 'act_abcDEF123456789012345678901';
+            const userResult = userSchema.safeParse(userId);
+            expect(userResult.success).toBe(true);
+            if (userResult.success)
+                expect(userResult.data).toBe(userId);
+            const appResult = appSchema.safeParse(appId);
+            expect(appResult.success).toBe(true);
+            if (appResult.success)
+                expect(appResult.data).toBe(appId);
+            const activityResult = activitySchema.safeParse(activityId);
+            expect(activityResult.success).toBe(true);
+            if (activityResult.success)
+                expect(activityResult.data).toBe(activityId);
+        });
+        test('should accept KSUID with mixed alphanumeric characters', () => {
+            const schema = KSUIDSchema('test');
+            const mixedId = 'test_1a2B3c4D5e6F7g8H9i0JkLmNoPq';
+            const result = schema.safeParse(mixedId);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toBe(mixedId);
+            }
+        });
+        test('should reject KSUID with wrong prefix', () => {
+            const schema = KSUIDSchema('usr');
+            const wrongPrefixId = 'app_123456789012345678901234567';
+            const result = schema.safeParse(wrongPrefixId);
+            expect(result.success).toBe(false);
+        });
+        test('should reject KSUID with missing prefix', () => {
+            const schema = KSUIDSchema('usr');
+            const noPrefixId = '123456789012345678901234567';
+            const result = schema.safeParse(noPrefixId);
+            expect(result.success).toBe(false);
+        });
+        test('should reject KSUID with missing underscore', () => {
+            const schema = KSUIDSchema('usr');
+            const noUnderscoreId = 'usr123456789012345678901234567';
+            const result = schema.safeParse(noUnderscoreId);
+            expect(result.success).toBe(false);
+        });
+        test('should reject KSUID with incorrect suffix length (too short)', () => {
+            const schema = KSUIDSchema('usr');
+            const shortId = 'usr_12345678901234567890123456';
+            const result = schema.safeParse(shortId);
+            expect(result.success).toBe(false);
+        });
+        test('should reject KSUID with incorrect suffix length (too long)', () => {
+            const schema = KSUIDSchema('usr');
+            const longId = 'usr_1234567890123456789012345678';
+            const result = schema.safeParse(longId);
+            expect(result.success).toBe(false);
+        });
+        test('should reject KSUID with invalid characters in suffix', () => {
+            const schema = KSUIDSchema('usr');
+            const invalidCharsId = 'usr_123456789012345678901234_*';
+            const result = schema.safeParse(invalidCharsId);
+            expect(result.success).toBe(false);
+        });
+        test('should reject KSUID with special characters in suffix', () => {
+            const schema = KSUIDSchema('usr');
+            const specialCharsId = 'usr_12345678901234567890123456@';
+            const result = schema.safeParse(specialCharsId);
+            expect(result.success).toBe(false);
+        });
+        test('should reject KSUID with spaces', () => {
+            const schema = KSUIDSchema('usr');
+            const spaceId = 'usr_1234567890123456789012345 7';
+            const result = schema.safeParse(spaceId);
+            expect(result.success).toBe(false);
+        });
+        test('should reject empty string', () => {
+            const schema = KSUIDSchema('usr');
+            const result = schema.safeParse('');
+            expect(result.success).toBe(false);
+        });
+        test('should reject non-string values', () => {
+            const schema = KSUIDSchema('usr');
+            const result1 = schema.safeParse(123);
+            expect(result1.success).toBe(false);
+            const result2 = schema.safeParse(null);
+            expect(result2.success).toBe(false);
+            const result3 = schema.safeParse(undefined);
+            expect(result3.success).toBe(false);
+            const result4 = schema.safeParse({});
+            expect(result4.success).toBe(false);
+        });
+        test('should work with complex prefixes', () => {
+            const complexSchema = KSUIDSchema('app_config');
+            const validComplexId = 'app_config_123456789012345678901234567';
+            const result = complexSchema.safeParse(validComplexId);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toBe(validComplexId);
+            }
+        });
+        test('should work with single character prefix', () => {
+            const singleCharSchema = KSUIDSchema('a');
+            const validSingleCharId = 'a_123456789012345678901234567';
+            const result = singleCharSchema.safeParse(validSingleCharId);
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toBe(validSingleCharId);
+            }
+        });
+        test('should create different schemas for different prefixes', () => {
+            const userSchema = KSUIDSchema('usr');
+            const orgSchema = KSUIDSchema('org');
+            const userId = 'usr_123456789012345678901234567';
+            const orgId = 'org_123456789012345678901234567';
+            // User schema should accept user ID but reject org ID
+            const userResult = userSchema.safeParse(userId);
+            expect(userResult.success).toBe(true);
+            if (userResult.success)
+                expect(userResult.data).toBe(userId);
+            const userOrgResult = userSchema.safeParse(orgId);
+            expect(userOrgResult.success).toBe(false);
+            // Org schema should accept org ID but reject user ID
+            const orgResult = orgSchema.safeParse(orgId);
+            expect(orgResult.success).toBe(true);
+            if (orgResult.success)
+                expect(orgResult.data).toBe(orgId);
+            const orgUserResult = orgSchema.safeParse(userId);
+            expect(orgUserResult.success).toBe(false);
+        });
+    });
+});

package/dist/esm/common/schema/jwt.d.ts

@@ -1,21 +1,34 @@
+import { z } from 'zod';
 /**
  * Ref: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1
  */
 export declare const Algorithm: {
-    DEFAULT: string;
-    HS256: string;
-    HS384: string;
-    HS512: string;
-    RS256: string;
-    RS384: string;
-    RS512: string;
-    ES256: string;
-    ES384: string;
-    ES512: string;
-    PS256: string;
-    PS384: string;
-    PS512: string;
+    readonly DEFAULT: "RS256";
+    readonly HS256: "HS256";
+    readonly HS384: "HS384";
+    readonly HS512: "HS512";
+    readonly RS256: "RS256";
+    readonly RS384: "RS384";
+    readonly RS512: "RS512";
+    readonly ES256: "ES256";
+    readonly ES384: "ES384";
+    readonly ES512: "ES512";
+    readonly PS256: "PS256";
+    readonly PS384: "PS384";
+    readonly PS512: "PS512";
 };
 export type AnyAlgorithm = (typeof Algorithm)[keyof typeof Algorithm];
-export declare const AlgorithmSchema: import("arktype/internal/methods/string.ts").StringType<string, {}>;
+export declare const AlgorithmSchema: z.ZodEnum<{
+    RS256: "RS256";
+    HS256: "HS256";
+    HS384: "HS384";
+    HS512: "HS512";
+    RS384: "RS384";
+    RS512: "RS512";
+    ES256: "ES256";
+    ES384: "ES384";
+    PS256: "PS256";
+    PS384: "PS384";
+    PS512: "PS512";
+}>;
 //# sourceMappingURL=jwt.d.ts.map

package/dist/esm/common/schema/jwt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jwt.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/jwt.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;CAerB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC;AAEtE,eAAO,MAAM,eAAe,qEAY3B,CAAC"}
+{"version":3,"file":"jwt.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/jwt.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;CAeZ,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC;AAEtE,eAAO,MAAM,eAAe;;;;;;;;;;;;EAYjB,CAAC"}

package/dist/esm/common/schema/jwt.js

@@ -1,4 +1,4 @@
-import { type } from 'arktype';
+import { z } from 'zod';
 /**
  * Ref: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1
  */
@@ -18,4 +18,16 @@ export const Algorithm = {
     PS384: 'PS384',
     PS512: 'PS512',
 };
-export const AlgorithmSchema = type.enumerated(Algorithm.HS256, Algorithm.HS384, Algorithm.HS512, Algorithm.RS256, Algorithm.RS384, Algorithm.RS512, Algorithm.ES256, Algorithm.ES384, Algorithm.PS256, Algorithm.PS384, Algorithm.PS512);
+export const AlgorithmSchema = z.enum([
+    Algorithm.HS256,
+    Algorithm.HS384,
+    Algorithm.HS512,
+    Algorithm.RS256,
+    Algorithm.RS384,
+    Algorithm.RS512,
+    Algorithm.ES256,
+    Algorithm.ES384,
+    Algorithm.PS256,
+    Algorithm.PS384,
+    Algorithm.PS512,
+]);

package/dist/esm/common/schema/jwt.test.d.ts

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

package/dist/esm/common/schema/jwt.test.d.ts.map

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