@go-mondo/identity-sdk 0.0.2-beta.8 → 0.0.2-beta.9

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/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.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

@@ -1,3 +1,7 @@
+/**
+ * Value
+ */
+export declare const MetadataValueSchema: import("arktype").BaseType<string | number | boolean, {}>;
 /**
  * Record
  */
@@ -31,18 +35,20 @@ export declare const UpsertMetadataPayloadSchema: import("arktype/internal/metho
 } | null>, {}>;
 export type UpsertMetadataInput = typeof UpsertMetadataPayloadSchema.inferIn;
 export type UpsertMetadataPayload = typeof UpsertMetadataPayloadSchema.inferOut;
-export declare const UpsertMetadataPayloadPropertySchema: import("arktype/internal/methods/object.ts").ObjectType<{
+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 UpsertMetadataPayloadProperty = typeof UpsertMetadataPayloadPropertySchema.inferOut;
+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> | Map<string, any>>;
+    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 {};

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

@@ -1 +1 @@
-{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../../../src/common/schema/metadata.ts"],"names":[],"mappings":"AAOA;;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;;;;mBAG6B,CAAC;AAChE,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;;;;cAGgC,CAAC;AACzE,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,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,CAgBvB;AAQD,eAAO,MAAM,yBAAyB;;MAEpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,yBAAyB,CAAC,QAAQ,CAAC"}
+{"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"}

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

@@ -2,7 +2,7 @@ import { match, type } from 'arktype';
 /**
  * Value
  */
-const MetadataValueSchema = type('string | number | boolean');
+export const MetadataValueSchema = type('string | number | boolean');
 /**
  * Record
  */
@@ -18,20 +18,32 @@ const MetadataMapMatch = match({
     undefined: () => new Map(),
 })
     .case(MetadataMapSchema, (s) => new Map(s))
-    .case(MetadataMapSchema, (s) => new Map(Object.entries(s || {}).map(([key, value]) => [key, value])))
+    .case(MetadataRecordSchema, (s) => new Map(Object.entries(s || {}).map(([key, value]) => [key, value])))
     .default(() => new Map());
 export const MetadataPayloadSchema = type('undefined | null')
     .or(MetadataMapSchema)
     .or(MetadataRecordSchema)
-    .pipe((map) => (map ? buildMetadataPayload(map) : undefined));
+    .pipe((map) => (map ? buildMetadataPayload(map) : undefined))
+    .narrow((n, ctx) => n && Object.keys(n).length > 10
+    ? ctx.reject({
+        expected: '10 items or less',
+        actual: `${Object.keys(n).length}`,
+    })
+    : true);
 export const MetadataPayloadPropertySchema = type({
     'metadata?': MetadataPayloadSchema,
 });
 export const UpsertMetadataPayloadSchema = type('undefined | null')
     .or(MetadataMapSchema)
     .or(MetadataRecordSchema)
-    .pipe((map) => (map ? buildUpsertMetadataPayload(map) || null : null));
-export const UpsertMetadataPayloadPropertySchema = type({
+    .pipe((map) => (map ? buildUpsertMetadataPayload(map) || null : null))
+    .narrow((n, ctx) => n && Object.keys(n).length > 10
+    ? ctx.reject({
+        expected: '10 items or less',
+        actual: `${Object.keys(n).length}`,
+    })
+    : true);
+export const UpsertMetadataPropertyPayloadSchema = type({
     'metadata?': UpsertMetadataPayloadSchema,
 });
 export function buildMetadataPayload(map) {
@@ -51,7 +63,13 @@ export function buildUpsertMetadataPayload(map) {
     if (!(map instanceof Map)) {
         return map;
     }
-    const result = Array.from(map.entries()).reduce((result, [key, value]) => {
+    return buildUpsertMetadataPayloadFromIterable(map.entries());
+}
+export function buildUpsertMetadataPayloadFromIterable(metadata) {
+    if (metadata == null) {
+        return null;
+    }
+    const result = Array.from(metadata).reduce((result, [key, value]) => {
         if (value == null || value === '') {
             return result;
         }

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

@@ -1,6 +1,6 @@
 import { type } from 'arktype';
 import { describe, expect, test } from 'vitest';
-import { MetadataMapPropertySchema, MetadataPayloadPropertySchema, } from './metadata.js';
+import { MetadataMapPropertySchema, MetadataPayloadPropertySchema, UpsertMetadataPayloadSchema, } from './metadata.js';
 describe('Common - Metadata', () => {
     describe('Map Property Schema', () => {
         test('should parse a record to a map', async () => {
@@ -57,4 +57,53 @@ describe('Common - Metadata', () => {
             expect(result?.metadata).is.undefined;
         });
     });
+    describe('Upsert Metadata Payload Schema', () => {
+        test('should handle incoming record', async () => {
+            const result = UpsertMetadataPayloadSchema({
+                foo: 'bar',
+                bar: 'baz',
+            });
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result?.foo).to.equal('bar');
+            expect(result?.bar).to.equal('baz');
+        });
+        test('should handle incoming map', async () => {
+            const result = UpsertMetadataPayloadSchema(new Map([
+                ['foo', 'bar'],
+                ['bar', 'baz'],
+            ]));
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result?.foo).to.equal('bar');
+            expect(result?.bar).to.equal('baz');
+        });
+        test('should only allow 10 items', async () => {
+            const result = UpsertMetadataPayloadSchema(new Map([
+                ['1', '1'],
+                ['2', '2'],
+                ['3', '3'],
+                ['4', '4'],
+                ['5', '5'],
+                ['6', '6'],
+                ['7', '7'],
+                ['8', '8'],
+                ['9', '9'],
+                ['10', '10'],
+                ['11', '11'],
+            ]));
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('Map Property Schema', () => {
+        test('should parse map to record', async () => {
+            const result = MetadataMapPropertySchema({
+                metadata: {
+                    foo: 'bar',
+                    bar: 'baz',
+                },
+            });
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result?.metadata?.get('foo')).to.equal('bar');
+            expect(result?.metadata?.get('bar')).to.equal('baz');
+        });
+    });
 });

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

@@ -1,6 +1,6 @@
 export declare const PaginationSchema: import("arktype/internal/methods/object.ts").ObjectType<{
-    pageSize?: string | number | undefined;
-    nextToken?: string | undefined;
+    pageSize?: string | number | null | undefined;
+    nextToken?: string | null | undefined;
 }, {}>;
 export type Pagination = typeof PaginationSchema.inferOut;
 //# sourceMappingURL=pagination.d.ts.map

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

@@ -1,5 +1,5 @@
 import { type } from 'arktype';
 export const PaginationSchema = type({
-    pageSize: type('string | number').optional(),
-    nextToken: type('string').optional(),
+    pageSize: type('string | number | null').optional(),
+    nextToken: type('string | null').optional(),
 });

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

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

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

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

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

@@ -0,0 +1,66 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { PaginationSchema } from './pagination.js';
+describe('Common Schema - Pagination', () => {
+    describe('PaginationSchema', () => {
+        test('should accept valid pagination with pageSize as string', () => {
+            const result = PaginationSchema({
+                pageSize: '10',
+                nextToken: 'token123',
+            });
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual({
+                pageSize: '10',
+                nextToken: 'token123',
+            });
+        });
+        test('should accept valid pagination with pageSize as number', () => {
+            const result = PaginationSchema({
+                pageSize: 20,
+                nextToken: 'token456',
+            });
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual({
+                pageSize: 20,
+                nextToken: 'token456',
+            });
+        });
+        test('should accept pagination with only pageSize', () => {
+            const result = PaginationSchema({
+                pageSize: '15',
+            });
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual({
+                pageSize: '15',
+            });
+        });
+        test('should accept pagination with only nextToken', () => {
+            const result = PaginationSchema({
+                nextToken: 'token789',
+            });
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual({
+                nextToken: 'token789',
+            });
+        });
+        test('should accept empty pagination object', () => {
+            const result = PaginationSchema({});
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual({});
+        });
+        test('should reject invalid pageSize type', () => {
+            const result = PaginationSchema({
+                pageSize: true,
+                nextToken: 'token123',
+            });
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject invalid nextToken type', () => {
+            const result = PaginationSchema({
+                pageSize: '10',
+                nextToken: 123,
+            });
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+});

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

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

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

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

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

@@ -0,0 +1,82 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { UniqueStringSetPayloadSchema, UniqueStringPayloadSchema, } from './sets.js';
+describe('Common Schema - Sets', () => {
+    describe('UniqueStringSetPayloadSchema', () => {
+        test('should accept Set of strings', () => {
+            const stringSet = new Set(['a', 'b', 'c']);
+            const result = UniqueStringSetPayloadSchema(stringSet);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toBeInstanceOf(Set);
+            expect(Array.from(result).sort()).toEqual(['a', 'b', 'c']);
+        });
+        test('should accept array of strings and convert to Set', () => {
+            const stringArray = ['x', 'y', 'z'];
+            const result = UniqueStringSetPayloadSchema(stringArray);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toBeInstanceOf(Set);
+            expect(Array.from(result).sort()).toEqual(['x', 'y', 'z']);
+        });
+        test('should handle duplicate strings in array', () => {
+            const stringArray = ['a', 'b', 'a', 'c', 'b'];
+            const result = UniqueStringSetPayloadSchema(stringArray);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toBeInstanceOf(Set);
+            expect(Array.from(result).sort()).toEqual(['a', 'b', 'c']);
+        });
+        test('should accept empty array', () => {
+            const result = UniqueStringSetPayloadSchema([]);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toBeInstanceOf(Set);
+            expect(result.size).toBe(0);
+        });
+        test('should accept empty Set', () => {
+            const emptySet = new Set();
+            const result = UniqueStringSetPayloadSchema(emptySet);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toBeInstanceOf(Set);
+            expect(result.size).toBe(0);
+        });
+        test('should reject non-string array elements', () => {
+            const result = UniqueStringSetPayloadSchema(['a', 123, 'b']);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject non-array, non-Set values', () => {
+            expect(UniqueStringSetPayloadSchema('string')).toBeInstanceOf(type.errors);
+            expect(UniqueStringSetPayloadSchema(123)).toBeInstanceOf(type.errors);
+            expect(UniqueStringSetPayloadSchema({})).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('UniqueStringPayloadSchema', () => {
+        test('should convert Set to array', () => {
+            const stringSet = new Set(['x', 'y', 'z']);
+            const result = UniqueStringPayloadSchema(stringSet);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(Array.isArray(result)).toBe(true);
+            expect(result.sort()).toEqual(['x', 'y', 'z']);
+        });
+        test('should convert array to unique array', () => {
+            const stringArray = ['a', 'b', 'a', 'c', 'b'];
+            const result = UniqueStringPayloadSchema(stringArray);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(Array.isArray(result)).toBe(true);
+            expect(result.sort()).toEqual(['a', 'b', 'c']);
+        });
+        test('should handle empty inputs', () => {
+            const emptySet = new Set();
+            const emptyArray = [];
+            const setResult = UniqueStringPayloadSchema(emptySet);
+            const arrayResult = UniqueStringPayloadSchema(emptyArray);
+            expect(setResult).not.toBeInstanceOf(type.errors);
+            expect(arrayResult).not.toBeInstanceOf(type.errors);
+            expect(setResult.length).toBe(0);
+            expect(arrayResult.length).toBe(0);
+        });
+        test('should maintain order from original Set', () => {
+            const orderedSet = new Set(['first', 'second', 'third']);
+            const result = UniqueStringPayloadSchema(orderedSet);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(['first', 'second', 'third']);
+        });
+    });
+});

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

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

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

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