@go-mondo/identity-sdk 0.0.1 → 0.0.2-beta.12

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

@@ -0,0 +1,73 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { AggregateSchema } from './aggregate.js';
+describe('Common Schema - Aggregate', () => {
+    describe('AggregateSchema', () => {
+        test('should accept valid aggregate with ids and count', () => {
+            const result = AggregateSchema({
+                ids: ['id1', 'id2', 'id3'],
+                count: 25,
+            });
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual({
+                ids: ['id1', 'id2', 'id3'],
+                count: 25,
+            });
+        });
+        test('should accept aggregate with only ids', () => {
+            const result = AggregateSchema({
+                ids: ['id1', 'id2'],
+            });
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual({
+                ids: ['id1', 'id2'],
+            });
+        });
+        test('should accept aggregate with only count', () => {
+            const result = AggregateSchema({
+                count: 42,
+            });
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual({
+                count: 42,
+            });
+        });
+        test('should accept empty aggregate', () => {
+            const result = AggregateSchema({});
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual({});
+        });
+        test('should accept aggregate with empty ids array', () => {
+            const result = AggregateSchema({
+                ids: [],
+                count: 0,
+            });
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual({
+                ids: [],
+                count: 0,
+            });
+        });
+        test('should reject invalid ids type', () => {
+            const result = AggregateSchema({
+                ids: 'not-an-array',
+                count: 10,
+            });
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject invalid count type', () => {
+            const result = AggregateSchema({
+                ids: ['id1'],
+                count: 'not-a-number',
+            });
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject non-string items in ids array', () => {
+            const result = AggregateSchema({
+                ids: ['id1', 123, 'id3'],
+                count: 3,
+            });
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+});

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

@@ -0,0 +1,18 @@
+import { type Pagination } from './pagination.js';
+export declare const CollectionSchema: import("arktype").Generic<[["t", unknown]], {
+    readonly items: "t[]";
+}, {}, {}>;
+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 | null | undefined;
+        nextToken?: string | null | undefined;
+    }, {}>, "?"];
+}, {}, {}>;
+export type PaginationCollection<I> = Collection<I> & {
+    pagination?: Pagination;
+};
+//# sourceMappingURL=collection.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,7 @@
+import { type } from 'arktype';
+import { PaginationSchema } from './pagination.js';
+export const CollectionSchema = type('<t>', { items: 't[]' });
+export const PaginationCollectionSchema = type('<t>', {
+    items: 't[]',
+    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,96 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { CollectionSchema, PaginationCollectionSchema } from './collection.js';
+describe('Common Schema - Collection', () => {
+    describe('CollectionSchema', () => {
+        test('should accept valid collection with string items', () => {
+            const StringCollectionSchema = CollectionSchema('string');
+            const result = StringCollectionSchema({
+                items: ['item1', 'item2', 'item3'],
+            });
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual({
+                items: ['item1', 'item2', 'item3'],
+            });
+        });
+        test('should accept valid collection with number items', () => {
+            const NumberCollectionSchema = CollectionSchema('number');
+            const result = NumberCollectionSchema({
+                items: [1, 2, 3],
+            });
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual({
+                items: [1, 2, 3],
+            });
+        });
+        test('should accept empty collection', () => {
+            const StringCollectionSchema = CollectionSchema('string');
+            const result = StringCollectionSchema({
+                items: [],
+            });
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual({
+                items: [],
+            });
+        });
+        test('should reject invalid items type', () => {
+            const StringCollectionSchema = CollectionSchema('string');
+            const result = StringCollectionSchema({
+                items: 'not-an-array',
+            });
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('PaginationCollectionSchema', () => {
+        test('should accept valid paginated collection', () => {
+            const StringPaginationCollectionSchema = PaginationCollectionSchema('string');
+            const result = StringPaginationCollectionSchema({
+                items: ['item1', 'item2'],
+                pagination: {
+                    pageSize: '10',
+                    nextToken: 'token123',
+                },
+            });
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual({
+                items: ['item1', 'item2'],
+                pagination: {
+                    pageSize: '10',
+                    nextToken: 'token123',
+                },
+            });
+        });
+        test('should accept collection without pagination', () => {
+            const StringPaginationCollectionSchema = PaginationCollectionSchema('string');
+            const result = StringPaginationCollectionSchema({
+                items: ['item1', 'item2'],
+            });
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual({
+                items: ['item1', 'item2'],
+            });
+        });
+        test('should accept collection with empty pagination', () => {
+            const StringPaginationCollectionSchema = PaginationCollectionSchema('string');
+            const result = StringPaginationCollectionSchema({
+                items: ['item1'],
+                pagination: {},
+            });
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual({
+                items: ['item1'],
+                pagination: {},
+            });
+        });
+        test('should reject invalid pagination', () => {
+            const StringPaginationCollectionSchema = PaginationCollectionSchema('string');
+            const result = StringPaginationCollectionSchema({
+                items: ['item1'],
+                pagination: {
+                    pageSize: true,
+                },
+            });
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+});

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

@@ -0,0 +1,39 @@
+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").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").Out<string>, {}>;
+export declare const OptionalDatePayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<(In: string | Date | undefined) => import("arktype").Out<string | undefined>, {}>;
+export type RequiredDatePayload = typeof RequiredDatePayloadSchema.inferOut;
+export type OptionalDatePayload = typeof OptionalDatePayloadSchema.inferOut;
+/**
+ * Created At
+ */
+export declare const CreatedAtPropertyPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    createdAt: (In: string | Date) => import("arktype").Out<string>;
+}, {}>;
+export type CreatedAtPropertyPayload = typeof CreatedAtPropertyPayloadSchema.inferOut;
+/**
+ * Updated At
+ */
+export declare const UpdatedAtPropertyPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    updatedAt: (In: string | Date) => import("arktype").Out<string>;
+}, {}>;
+export type UpdatedAtPropertyPayload = typeof UpdatedAtPropertyPayloadSchema.inferOut;
+/**
+ * Deleted At
+ */
+export declare const DeletedAtPropertyPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    deletedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
+}, {}>;
+export type DeletedAtPropertyPayload = typeof DeletedAtPropertyPayloadSchema.inferOut;
+/**
+ * Deactivated At
+ */
+export declare const DeactivatedAtPropertyPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    deactivatedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
+}, {}>;
+export type DeactivatedAtPropertyPayload = typeof DeactivatedAtPropertyPayloadSchema.inferOut;
+//# sourceMappingURL=dates.d.ts.map

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

@@ -0,0 +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,wHAAqC,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,mHAErC,CAAC;AACF,eAAO,MAAM,yBAAyB,2IAErC,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"}

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

@@ -0,0 +1,31 @@
+import { type } from 'arktype';
+// Normalizing to a Date object
+export const RequiredDateSchema = type('Date').or('string.date.iso.parse');
+export const OptionalDateSchema = RequiredDateSchema.or('undefined');
+// 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());
+/**
+ * Created At
+ */
+export const CreatedAtPropertyPayloadSchema = type({
+    createdAt: RequiredDatePayloadSchema,
+});
+/**
+ * Updated At
+ */
+export const UpdatedAtPropertyPayloadSchema = type({
+    updatedAt: RequiredDatePayloadSchema,
+});
+/**
+ * Deleted At
+ */
+export const DeletedAtPropertyPayloadSchema = type({
+    'deletedAt?': OptionalDatePayloadSchema,
+});
+/**
+ * Deactivated At
+ */
+export const DeactivatedAtPropertyPayloadSchema = type({
+    'deactivatedAt?': OptionalDatePayloadSchema,
+});

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

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

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

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

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

@@ -0,0 +1,31 @@
+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);
+        });
+        test('should accept a Date object', async () => {
+            const result = RequiredDateSchema(new Date());
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).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);
+        });
+        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);
+        });
+    });
+});

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

@@ -0,0 +1,2 @@
+export declare const KSUIDSchema: (prefix: string) => import("arktype/internal/methods/string.ts").StringType<string, {}>;
+//# 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":"AAEA,eAAO,MAAM,WAAW,GAAI,QAAQ,MAAM,wEACH,CAAC"}

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

@@ -0,0 +1,2 @@
+import { type } from 'arktype';
+export const KSUIDSchema = (prefix) => type(`/^${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,114 @@
+import { type } from 'arktype';
+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(validId);
+            expect(result).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';
+            expect(userSchema(userId)).toBe(userId);
+            expect(appSchema(appId)).toBe(appId);
+            expect(activitySchema(activityId)).toBe(activityId);
+        });
+        test('should accept KSUID with mixed alphanumeric characters', () => {
+            const schema = KSUIDSchema('test');
+            const mixedId = 'test_1a2B3c4D5e6F7g8H9i0JkLmNoPq';
+            const result = schema(mixedId);
+            expect(result).toBe(mixedId);
+        });
+        test('should reject KSUID with wrong prefix', () => {
+            const schema = KSUIDSchema('usr');
+            const wrongPrefixId = 'app_123456789012345678901234567';
+            const result = schema(wrongPrefixId);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject KSUID with missing prefix', () => {
+            const schema = KSUIDSchema('usr');
+            const noPrefixId = '123456789012345678901234567';
+            const result = schema(noPrefixId);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject KSUID with missing underscore', () => {
+            const schema = KSUIDSchema('usr');
+            const noUnderscoreId = 'usr123456789012345678901234567';
+            const result = schema(noUnderscoreId);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject KSUID with incorrect suffix length (too short)', () => {
+            const schema = KSUIDSchema('usr');
+            const shortId = 'usr_12345678901234567890123456';
+            const result = schema(shortId);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject KSUID with incorrect suffix length (too long)', () => {
+            const schema = KSUIDSchema('usr');
+            const longId = 'usr_1234567890123456789012345678';
+            const result = schema(longId);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject KSUID with invalid characters in suffix', () => {
+            const schema = KSUIDSchema('usr');
+            const invalidCharsId = 'usr_123456789012345678901234_*';
+            const result = schema(invalidCharsId);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject KSUID with special characters in suffix', () => {
+            const schema = KSUIDSchema('usr');
+            const specialCharsId = 'usr_12345678901234567890123456@';
+            const result = schema(specialCharsId);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject KSUID with spaces', () => {
+            const schema = KSUIDSchema('usr');
+            const spaceId = 'usr_1234567890123456789012345 7';
+            const result = schema(spaceId);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject empty string', () => {
+            const schema = KSUIDSchema('usr');
+            const result = schema('');
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject non-string values', () => {
+            const schema = KSUIDSchema('usr');
+            expect(schema(123)).toBeInstanceOf(type.errors);
+            expect(schema(null)).toBeInstanceOf(type.errors);
+            expect(schema(undefined)).toBeInstanceOf(type.errors);
+            expect(schema({})).toBeInstanceOf(type.errors);
+        });
+        test('should work with complex prefixes', () => {
+            const complexSchema = KSUIDSchema('app_config');
+            const validComplexId = 'app_config_123456789012345678901234567';
+            const result = complexSchema(validComplexId);
+            expect(result).toBe(validComplexId);
+        });
+        test('should work with single character prefix', () => {
+            const singleCharSchema = KSUIDSchema('a');
+            const validSingleCharId = 'a_123456789012345678901234567';
+            const result = singleCharSchema(validSingleCharId);
+            expect(result).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
+            expect(userSchema(userId)).toBe(userId);
+            expect(userSchema(orgId)).toBeInstanceOf(type.errors);
+            // Org schema should accept org ID but reject user ID
+            expect(orgSchema(orgId)).toBe(orgId);
+            expect(orgSchema(userId)).toBeInstanceOf(type.errors);
+        });
+    });
+});

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

@@ -0,0 +1,21 @@
+/**
+ * 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;
+};
+export type AnyAlgorithm = (typeof Algorithm)[keyof typeof Algorithm];
+export declare const AlgorithmSchema: import("arktype/internal/methods/string.ts").StringType<string, {}>;
+//# sourceMappingURL=jwt.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,21 @@
+import { type } from 'arktype';
+/**
+ * Ref: https://datatracker.ietf.org/doc/html/rfc7518#section-3.1
+ */
+export const Algorithm = {
+    // DEFAULT: 'ES256',
+    DEFAULT: 'RS256',
+    HS256: 'HS256',
+    HS384: 'HS384',
+    HS512: 'HS512',
+    RS256: 'RS256',
+    RS384: 'RS384',
+    RS512: 'RS512',
+    ES256: 'ES256',
+    ES384: 'ES384',
+    ES512: 'ES512',
+    PS256: 'PS256',
+    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);

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":""}

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

@@ -0,0 +1,54 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { Algorithm, AlgorithmSchema } from './jwt.js';
+describe('Common Schema - JWT', () => {
+    describe('Algorithm constants', () => {
+        test('should have correct algorithm values', () => {
+            expect(Algorithm.DEFAULT).toBe('RS256');
+            expect(Algorithm.HS256).toBe('HS256');
+            expect(Algorithm.HS384).toBe('HS384');
+            expect(Algorithm.HS512).toBe('HS512');
+            expect(Algorithm.RS256).toBe('RS256');
+            expect(Algorithm.RS384).toBe('RS384');
+            expect(Algorithm.RS512).toBe('RS512');
+            expect(Algorithm.ES256).toBe('ES256');
+            expect(Algorithm.ES384).toBe('ES384');
+            expect(Algorithm.ES512).toBe('ES512');
+            expect(Algorithm.PS256).toBe('PS256');
+            expect(Algorithm.PS384).toBe('PS384');
+            expect(Algorithm.PS512).toBe('PS512');
+        });
+    });
+    describe('AlgorithmSchema', () => {
+        test('should accept valid HMAC algorithms', () => {
+            expect(AlgorithmSchema('HS256')).not.toBeInstanceOf(type.errors);
+            expect(AlgorithmSchema('HS384')).not.toBeInstanceOf(type.errors);
+            expect(AlgorithmSchema('HS512')).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept valid RSA algorithms', () => {
+            expect(AlgorithmSchema('RS256')).not.toBeInstanceOf(type.errors);
+            expect(AlgorithmSchema('RS384')).not.toBeInstanceOf(type.errors);
+            expect(AlgorithmSchema('RS512')).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept valid ECDSA algorithms', () => {
+            expect(AlgorithmSchema('ES256')).not.toBeInstanceOf(type.errors);
+            expect(AlgorithmSchema('ES384')).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept valid PSS algorithms', () => {
+            expect(AlgorithmSchema('PS256')).not.toBeInstanceOf(type.errors);
+            expect(AlgorithmSchema('PS384')).not.toBeInstanceOf(type.errors);
+            expect(AlgorithmSchema('PS512')).not.toBeInstanceOf(type.errors);
+        });
+        test('should reject invalid algorithms', () => {
+            expect(AlgorithmSchema('INVALID')).toBeInstanceOf(type.errors);
+            expect(AlgorithmSchema('HS128')).toBeInstanceOf(type.errors);
+            expect(AlgorithmSchema('RS128')).toBeInstanceOf(type.errors);
+            expect(AlgorithmSchema('')).toBeInstanceOf(type.errors);
+        });
+        test('should reject non-string values', () => {
+            expect(AlgorithmSchema(123)).toBeInstanceOf(type.errors);
+            expect(AlgorithmSchema(null)).toBeInstanceOf(type.errors);
+            expect(AlgorithmSchema(undefined)).toBeInstanceOf(type.errors);
+        });
+    });
+});

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

@@ -0,0 +1,55 @@
+/**
+ * Value
+ */
+export declare const MetadataValueSchema: import("arktype").BaseType<string | number | boolean, {}>;
+/**
+ * Record
+ */
+declare const MetadataRecordSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    [x: string]: string | number | boolean;
+}, {}>;
+export type MetadataRecord = typeof MetadataRecordSchema.inferOut;
+/**
+ * Map
+ */
+declare const MetadataMapSchema: import("arktype/internal/methods/object.ts").ObjectType<Map<string, string | number | boolean>, {}>;
+export type MetadataMap = typeof MetadataMapSchema.inferOut;
+export declare const MetadataPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<(In: {
+    [x: string]: string | number | boolean;
+} | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
+    [x: string]: string | number | boolean;
+} | undefined>, {}>;
+export type MetadataPayload = typeof MetadataPayloadSchema.inferOut;
+export declare const MetadataPayloadPropertySchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
+        [x: string]: string | number | boolean;
+    } | undefined>) | undefined;
+}, {}>;
+export type MetadataPayloadProperty = typeof MetadataPayloadPropertySchema.inferOut;
+export declare const UpsertMetadataPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<(In: {
+    [x: string]: string | number | boolean;
+} | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
+    [x: string]: string | number | boolean;
+} | null>, {}>;
+export type UpsertMetadataInput = typeof UpsertMetadataPayloadSchema.inferIn;
+export type UpsertMetadataPayload = typeof UpsertMetadataPayloadSchema.inferOut;
+export declare const UpsertMetadataPropertyPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
+        [x: string]: string | number | boolean;
+    } | null>) | undefined;
+}, {}>;
+export type UpsertMetadataPropertyInput = typeof UpsertMetadataPropertyPayloadSchema.inferIn;
+export type UpsertMetadataPropertyPayload = typeof UpsertMetadataPropertyPayloadSchema.inferOut;
+export declare function buildMetadataPayload(map: MetadataMap | MetadataRecord): MetadataRecord | undefined;
+export declare function buildUpsertMetadataPayload(map: MetadataMap | MetadataRecord): MetadataRecord | null;
+export declare function buildUpsertMetadataPayloadFromIterable(metadata: Iterable<[string, string | number | boolean]> | null): MetadataRecord | null;
+export declare const MetadataMapPropertySchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    metadata: (In: import("arktype/internal/attributes.ts").Default<unknown, Map<string, string | number | boolean>>) => import("arktype").Out<Map<string, string | number | boolean>>;
+}, {}>;
+export type MetadataMapProperty = typeof MetadataMapPropertySchema.inferOut;
+export {};
+//# sourceMappingURL=metadata.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/metadata.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,eAAO,MAAM,mBAAmB,2DAAoC,CAAC;AAErE;;GAEG;AACH,QAAA,MAAM,oBAAoB;;MAA4C,CAAC;AACvE,MAAM,MAAM,cAAc,GAAG,OAAO,oBAAoB,CAAC,QAAQ,CAAC;AAElE;;GAEG;AACH,QAAA,MAAM,iBAAiB,qGAEtB,CAAC;AACF,MAAM,MAAM,WAAW,GAAG,OAAO,iBAAiB,CAAC,QAAQ,CAAC;AAoB5D,eAAO,MAAM,qBAAqB;;;;mBAW/B,CAAC;AACJ,MAAM,MAAM,eAAe,GAAG,OAAO,qBAAqB,CAAC,QAAQ,CAAC;AAEpE,eAAO,MAAM,6BAA6B;;;;;;MAExC,CAAC;AACH,MAAM,MAAM,uBAAuB,GACjC,OAAO,6BAA6B,CAAC,QAAQ,CAAC;AAEhD,eAAO,MAAM,2BAA2B;;;;cAWrC,CAAC;AACJ,MAAM,MAAM,mBAAmB,GAAG,OAAO,2BAA2B,CAAC,OAAO,CAAC;AAC7E,MAAM,MAAM,qBAAqB,GAAG,OAAO,2BAA2B,CAAC,QAAQ,CAAC;AAEhF,eAAO,MAAM,mCAAmC;;;;;;MAE9C,CAAC;AACH,MAAM,MAAM,2BAA2B,GACrC,OAAO,mCAAmC,CAAC,OAAO,CAAC;AACrD,MAAM,MAAM,6BAA6B,GACvC,OAAO,mCAAmC,CAAC,QAAQ,CAAC;AAEtD,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,WAAW,GAAG,cAAc,GAChC,cAAc,GAAG,SAAS,CAgB5B;AAED,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,WAAW,GAAG,cAAc,GAChC,cAAc,GAAG,IAAI,CAMvB;AAED,wBAAgB,sCAAsC,CACpD,QAAQ,EAAE,QAAQ,CAAC,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,GAC7D,cAAc,GAAG,IAAI,CAgBvB;AAQD,eAAO,MAAM,yBAAyB;;MAEpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,yBAAyB,CAAC,QAAQ,CAAC"}