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

package/dist/esm/association/schema.d.ts

@@ -17,6 +17,11 @@ export declare const AssociationAttributesReferenceSchema: import("arktype/inter
 export type AssociationAttributesReference = typeof AssociationAttributesReferenceSchema.inferOut;
 export type AssociationReference = AssociationIdReference | AssociationAttributesReference;
 export declare const AssociationObjectSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    status: import("arktype/internal/attributes.ts").Default<"enabled" | "disabled", "disabled">;
+    label: string;
+    model: "App";
+} | {
     id: string;
     givenName?: string | undefined;
     middleName?: string | undefined;
@@ -27,11 +32,6 @@ export declare const AssociationObjectSchema: import("arktype/internal/methods/o
     phoneNumber?: string | undefined;
     status: import("arktype/internal/attributes.ts").Default<"active" | "suspended" | "unverified", "unverified">;
     model: "User";
-} | {
-    id: string;
-    status: import("arktype/internal/attributes.ts").Default<"enabled" | "disabled", "disabled">;
-    label: string;
-    model: "App";
 } | {
     id: string;
     name: string;
@@ -50,6 +50,11 @@ export declare const AssociationObjectSchema: import("arktype/internal/methods/o
 export type AssociationObject = typeof AssociationObjectSchema.inferOut;
 export declare const ObjectPropertySchema: import("arktype/internal/methods/object.ts").ObjectType<{
     object: {
+        id: string;
+        status: import("arktype/internal/attributes.ts").Default<"enabled" | "disabled", "disabled">;
+        label: string;
+        model: "App";
+    } | {
         id: string;
         givenName?: string | undefined;
         middleName?: string | undefined;
@@ -60,11 +65,6 @@ export declare const ObjectPropertySchema: import("arktype/internal/methods/obje
         phoneNumber?: string | undefined;
         status: import("arktype/internal/attributes.ts").Default<"active" | "suspended" | "unverified", "unverified">;
         model: "User";
-    } | {
-        id: string;
-        status: import("arktype/internal/attributes.ts").Default<"enabled" | "disabled", "disabled">;
-        label: string;
-        model: "App";
     } | {
         id: string;
         name: string;
@@ -83,6 +83,11 @@ export declare const ObjectPropertySchema: import("arktype/internal/methods/obje
 }, {}>;
 export declare const AssociationSchema: import("arktype/internal/methods/object.ts").ObjectType<{
     object: {
+        id: string;
+        status: import("arktype/internal/attributes.ts").Default<"enabled" | "disabled", "disabled">;
+        label: string;
+        model: "App";
+    } | {
         id: string;
         givenName?: string | undefined;
         middleName?: string | undefined;
@@ -93,11 +98,6 @@ export declare const AssociationSchema: import("arktype/internal/methods/object.
         phoneNumber?: string | undefined;
         status: import("arktype/internal/attributes.ts").Default<"active" | "suspended" | "unverified", "unverified">;
         model: "User";
-    } | {
-        id: string;
-        status: import("arktype/internal/attributes.ts").Default<"enabled" | "disabled", "disabled">;
-        label: string;
-        model: "App";
     } | {
         id: string;
         name: string;
@@ -117,14 +117,14 @@ export declare const AssociationSchema: import("arktype/internal/methods/object.
     expiresAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
     deletedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
     deactivatedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
-    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>>;
 }, {}>;
 declare const RootAssociationProperties: import("arktype/internal/methods/object.ts").ObjectType<{
     updatedAt: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
     expiresAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
     deletedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
     deactivatedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
-    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>>;
 }, {}>;
 type RootAssociationProperties = typeof RootAssociationProperties.inferIn;
 export type AssociationProperties<O extends AssociationObject = AssociationObject> = RootAssociationProperties & {
@@ -135,7 +135,7 @@ declare const RootAssociation: import("arktype/internal/methods/object.ts").Obje
     expiresAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
     deletedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
     deactivatedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
-    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>>;
 }, {}>;
 type RootAssociation = typeof RootAssociation.inferOut;
 export type Association<O extends AssociationObject = AssociationObject> = RootAssociation & {
@@ -147,6 +147,11 @@ export declare const AssociationPayloadSchema: import("arktype/internal/methods/
     deletedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
     deactivatedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
     object: {
+        id: string;
+        status: import("arktype/internal/attributes.ts").Default<"enabled" | "disabled", "disabled">;
+        label: string;
+        model: "App";
+    } | {
         id: string;
         givenName?: string | undefined;
         middleName?: string | undefined;
@@ -157,11 +162,6 @@ export declare const AssociationPayloadSchema: import("arktype/internal/methods/
         phoneNumber?: string | undefined;
         status: import("arktype/internal/attributes.ts").Default<"active" | "suspended" | "unverified", "unverified">;
         model: "User";
-    } | {
-        id: string;
-        status: import("arktype/internal/attributes.ts").Default<"enabled" | "disabled", "disabled">;
-        label: string;
-        model: "App";
     } | {
         id: string;
         name: string;

package/dist/esm/association/schema.js

@@ -3,7 +3,7 @@ import { AppAssociationReferenceSchema } from '../app/schema.js';
 import { PermissionAssociationReferenceSchema, RoleAssociationReferenceSchema, } from '../authorization/index.js';
 import { OptionalDatePayloadSchema, OptionalDateSchema, RequiredDatePayloadSchema, RequiredDateSchema, } from '../common/schema/dates.js';
 import { MetadataMapPropertySchema, MetadataPayloadPropertySchema, } from '../common/schema/metadata.js';
-import { OrganizationAssociationReferenceSchema } from '../customer/schema/organization.js';
+import { OrganizationAssociationReferenceSchema } from '../customer/organization/schema.js';
 import { UserAssociationReferenceSchema } from '../customer/users/schema.js';
 export const AssociationObjectType = {
     USER: 'User',

package/dist/esm/association/schema.test.d.ts

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

package/dist/esm/association/schema.test.d.ts.map

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

package/dist/esm/association/schema.test.js

@@ -0,0 +1,119 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { generateAppId } from '../app/utils.js';
+import { generatePermissionId, generateRoleId, } from '../authorization/schema.js';
+import { generateUserId } from '../customer/schema.js';
+import { AssociationObjectType, AssociationIdReferenceSchema, AssociationAttributesReferenceSchema, AssociationObjectSchema, } from './schema.js';
+describe('Association - Schema', () => {
+    describe('AssociationObjectType constants', () => {
+        test('should have correct object type values', () => {
+            expect(AssociationObjectType.USER).toBe('User');
+            expect(AssociationObjectType.ORGANIZATION).toBe('Organization');
+            expect(AssociationObjectType.ROLE).toBe('Role');
+            expect(AssociationObjectType.APP).toBe('App');
+            expect(AssociationObjectType.PERMISSION).toBe('Permission');
+        });
+    });
+    describe('AssociationIdReferenceSchema', () => {
+        test('should accept valid id reference', () => {
+            const reference = { id: 'any_string_id' };
+            const result = AssociationIdReferenceSchema(reference);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(reference);
+        });
+        test('should reject missing id', () => {
+            const result = AssociationIdReferenceSchema({});
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject non-string id', () => {
+            const reference = { id: 123 };
+            const result = AssociationIdReferenceSchema(reference);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('AssociationAttributesReferenceSchema', () => {
+        test('should accept id with additional attributes', () => {
+            const reference = {
+                id: 'test_id',
+                name: 'Test Name',
+                status: 'active',
+                metadata: { key: 'value' },
+            };
+            const result = AssociationAttributesReferenceSchema(reference);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(reference);
+        });
+        test('should accept minimal reference with just id', () => {
+            const reference = { id: 'minimal_id' };
+            const result = AssociationAttributesReferenceSchema(reference);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(reference);
+        });
+        test('should reject missing id', () => {
+            const reference = { name: 'Test', status: 'active' };
+            const result = AssociationAttributesReferenceSchema(reference);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('AssociationObjectSchema', () => {
+        // Note: User association reference has complex requirements
+        // that depend on UserNamePropertiesSchema and EmailOrPhonePropertiesSchema
+        test('should accept App association reference', () => {
+            const appAssociation = {
+                id: generateAppId(),
+                status: 'enabled',
+                label: 'Test App',
+                model: 'App',
+            };
+            const result = AssociationObjectSchema(appAssociation);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept Role association reference', () => {
+            const roleAssociation = {
+                id: generateRoleId(),
+                name: 'admin',
+                status: 'enabled',
+                model: 'Role',
+            };
+            const result = AssociationObjectSchema(roleAssociation);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept Permission association reference', () => {
+            const permissionAssociation = {
+                id: generatePermissionId(),
+                name: 'read:users',
+                status: 'enabled',
+                model: 'Permission',
+            };
+            const result = AssociationObjectSchema(permissionAssociation);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should reject invalid association object', () => {
+            const invalidAssociation = {
+                id: 'test_id',
+                name: 'Test',
+                model: 'InvalidModel',
+            };
+            const result = AssociationObjectSchema(invalidAssociation);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject association missing required fields', () => {
+            const incompleteAssociation = {
+                id: generateUserId(),
+                // missing required fields for any valid association type
+            };
+            const result = AssociationObjectSchema(incompleteAssociation);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject association with mismatched model and data', () => {
+            const mismatchedAssociation = {
+                id: generateUserId(),
+                name: 'admin', // role field
+                status: 'enabled',
+                model: 'User', // but missing user fields
+            };
+            const result = AssociationObjectSchema(mismatchedAssociation);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+});

package/dist/esm/authentication/factors/schema.test.js

@@ -1,5 +1,6 @@
 import { type } from 'arktype';
 import { describe, expect, test } from 'vitest';
+import { generateStrategyId } from '../utils.js';
 import { AuthenticationFactorPayloadSchema, AuthenticationFactorsPayloadSchema, UpsertAuthenticationFactorsPayloadSchema, } from './schema.js';
 describe('Authentication - Factors', () => {
     describe('Schema', () => {
@@ -9,7 +10,7 @@ describe('Authentication - Factors', () => {
                 updatedAt: new Date(),
                 factors: [
                     {
-                        id: '123',
+                        id: generateStrategyId(),
                     },
                 ],
             })).not.toBeInstanceOf(type.errors);
@@ -24,7 +25,7 @@ describe('Authentication - Factors', () => {
             expect(UpsertAuthenticationFactorsPayloadSchema({
                 factors: [
                     {
-                        id: '123',
+                        id: generateStrategyId(),
                     },
                 ],
             })).not.toBeInstanceOf(type.errors);
@@ -42,42 +43,42 @@ describe('Authentication - Factors', () => {
             expect(AuthenticationFactorsPayloadSchema({
                 createdAt: new Date(),
                 updatedAt: new Date(),
-                factors: { id: '123' },
+                factors: { id: generateStrategyId() },
             })).toBeInstanceOf(type.errors);
             // Factor array of string
             expect(AuthenticationFactorsPayloadSchema({
                 createdAt: new Date(),
                 updatedAt: new Date(),
-                factors: ['123'],
+                factors: [generateStrategyId()],
             })).toBeInstanceOf(type.errors);
         });
         test('should accept various next factors types', async () => {
             // Undefined
             expect(AuthenticationFactorPayloadSchema({
-                id: '123',
+                id: generateStrategyId(),
                 nextFactors: undefined,
             })).not.toBeInstanceOf(type.errors);
             // Array
             expect(AuthenticationFactorPayloadSchema({
-                id: '123',
+                id: generateStrategyId(),
                 nextFactors: [
                     {
-                        id: '456',
+                        id: generateStrategyId(),
                     },
                 ],
             })).not.toBeInstanceOf(type.errors);
             // Deeply nested array
             expect(AuthenticationFactorPayloadSchema({
-                id: '123',
+                id: generateStrategyId(),
                 nextFactors: [
                     {
-                        id: '456',
+                        id: generateStrategyId(),
                         nextFactors: [
                             {
-                                id: '456',
+                                id: generateStrategyId(),
                                 nextFactors: [
                                     {
-                                        id: '456',
+                                        id: generateStrategyId(),
                                     },
                                 ],
                             },
@@ -89,7 +90,7 @@ describe('Authentication - Factors', () => {
         test('should throw error for invalid factor id', async () => {
             // Number
             expect(AuthenticationFactorsPayloadSchema({
-                id: 123,
+                id: generateStrategyId(),
             })).toBeInstanceOf(type.errors);
             // Null
             expect(AuthenticationFactorsPayloadSchema({
@@ -103,18 +104,18 @@ describe('Authentication - Factors', () => {
         test('should throw error for invalid next factors', async () => {
             // String
             expect(AuthenticationFactorsPayloadSchema({
-                id: '123',
-                nextFactors: '123',
+                id: generateStrategyId(),
+                nextFactors: generateStrategyId(),
             })).toBeInstanceOf(type.errors);
             // Object
             expect(AuthenticationFactorsPayloadSchema({
-                id: '123',
-                nextFactors: { id: '123' },
+                id: generateStrategyId(),
+                nextFactors: { id: generateStrategyId() },
             })).toBeInstanceOf(type.errors);
             // Array
             expect(AuthenticationFactorsPayloadSchema({
-                id: '123',
-                nextFactors: ['123'],
+                id: generateStrategyId(),
+                nextFactors: [generateStrategyId()],
             })).toBeInstanceOf(type.errors);
         });
     });

package/dist/esm/authentication/providers/schema.js

@@ -1,7 +1,7 @@
 import { type } from 'arktype';
 import { OptionalDatePayloadSchema, RequiredDatePayloadSchema, } from '../../common/schema/dates.js';
 import { MetadataPayloadPropertySchema } from '../../common/schema/metadata.js';
-import { UserIdSchema } from '../../customer/users/schema.js';
+import { UserIdSchema } from '../../customer/schema.js';
 import { StrategyIdSchema } from '../strategies/schema/base.js';
 export const ProviderType = {
     MONDO: 'mondo',

package/dist/esm/authentication/sessions/schema.d.ts

@@ -10,7 +10,7 @@ export declare const SessionIdPropertySchema: import("arktype/internal/methods/o
     id: string;
 }, {}>;
 export type SessionIdProperty = typeof SessionIdPropertySchema.inferOut;
-export declare const SessionStatusSchema: import("arktype/internal/methods/string.ts").StringType<"initiated" | "authenticated" | "pending", {}>;
+export declare const SessionStatusSchema: import("arktype/internal/methods/string.ts").StringType<"pending" | "initiated" | "authenticated", {}>;
 export declare const SessionAuthenticationFactorSchema: import("arktype/internal/methods/object.ts").ObjectType<{
     id: string;
     type: "email" | "password" | "totp";
@@ -22,7 +22,7 @@ export declare const SessionAuthenticationFactorHistorySchema: import("arktype/i
 export type SessionAuthenticationFactorHistory = typeof SessionAuthenticationFactorHistorySchema.inferOut;
 export declare const SessionSchema: import("arktype/internal/methods/object.ts").ObjectType<{
     id: string;
-    status: "initiated" | "authenticated" | "pending";
+    status: "pending" | "initiated" | "authenticated";
     user?: string | undefined;
     userAgent?: string | undefined;
     sourceIp?: string | undefined;
@@ -38,13 +38,13 @@ export declare const SessionSchema: import("arktype/internal/methods/object.ts")
     updatedAt: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
     deletedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
     deactivatedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
-    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 SessionProperties = typeof SessionSchema.inferIn;
 export type Session = typeof SessionSchema.inferOut;
 export declare const SessionPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
     id: string;
-    status: "initiated" | "authenticated" | "pending";
+    status: "pending" | "initiated" | "authenticated";
     user?: string | undefined;
     userAgent?: string | undefined;
     sourceIp?: string | undefined;
@@ -69,7 +69,7 @@ export declare const SessionPayloadSchema: import("arktype/internal/methods/obje
 export type SessionPayload = typeof SessionPayloadSchema.inferOut;
 export declare const SessionAssociationReferenceSchema: import("arktype/internal/methods/object.ts").ObjectType<{
     id: string;
-    status: "initiated" | "authenticated" | "pending";
+    status: "pending" | "initiated" | "authenticated";
     user?: string | undefined;
     userAgent?: string | undefined;
     sourceIp?: string | undefined;

package/dist/esm/authentication/sessions/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/authentication/sessions/schema.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,aAAa;;;;CAIhB,CAAC;AAEX,MAAM,MAAM,gBAAgB,GAC1B,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,OAAO,aAAa,CAAC,CAAC;AAErD,eAAO,MAAM,eAAe,qEAAc,CAAC;AAC3C,MAAM,MAAM,SAAS,GAAG,OAAO,eAAe,CAAC,QAAQ,CAAC;AAExD,eAAO,MAAM,uBAAuB;;MAElC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,uBAAuB,CAAC,QAAQ,CAAC;AAExE,eAAO,MAAM,mBAAmB,wGAI/B,CAAC;AAEF,eAAO,MAAM,iCAAiC;;;;;MAK5C,CAAC;AACH,MAAM,MAAM,2BAA2B,GACrC,OAAO,iCAAiC,CAAC,QAAQ,CAAC;AAMpD,eAAO,MAAM,wCAAwC,oKAKlD,CAAC;AACJ,MAAM,MAAM,kCAAkC,GAC5C,OAAO,wCAAwC,CAAC,QAAQ,CAAC;AAW3D,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;MAMO,CAAC;AAClC,MAAM,MAAM,iBAAiB,GAAG,OAAO,aAAa,CAAC,OAAO,CAAC;AAC7D,MAAM,MAAM,OAAO,GAAG,OAAO,aAAa,CAAC,QAAQ,CAAC;AAEpD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;MAMI,CAAC;AACtC,MAAM,MAAM,cAAc,GAAG,OAAO,oBAAoB,CAAC,QAAQ,CAAC;AAElE,eAAO,MAAM,iCAAiC;;;;;;;;;MAU5C,CAAC;AACH,MAAM,MAAM,2BAA2B,GACrC,OAAO,iCAAiC,CAAC,QAAQ,CAAC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/authentication/sessions/schema.ts"],"names":[],"mappings":"AAmBA,eAAO,MAAM,aAAa;;;;CAIhB,CAAC;AAEX,MAAM,MAAM,gBAAgB,GAC1B,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,OAAO,aAAa,CAAC,CAAC;AAErD,eAAO,MAAM,eAAe,qEAAuC,CAAC;AACpE,MAAM,MAAM,SAAS,GAAG,OAAO,eAAe,CAAC,QAAQ,CAAC;AAExD,eAAO,MAAM,uBAAuB;;MAElC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,uBAAuB,CAAC,QAAQ,CAAC;AAExE,eAAO,MAAM,mBAAmB,wGAI/B,CAAC;AAEF,eAAO,MAAM,iCAAiC;;;;;MAK5C,CAAC;AACH,MAAM,MAAM,2BAA2B,GACrC,OAAO,iCAAiC,CAAC,QAAQ,CAAC;AAMpD,eAAO,MAAM,wCAAwC,oKAKlD,CAAC;AACJ,MAAM,MAAM,kCAAkC,GAC5C,OAAO,wCAAwC,CAAC,QAAQ,CAAC;AAW3D,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;MAMO,CAAC;AAClC,MAAM,MAAM,iBAAiB,GAAG,OAAO,aAAa,CAAC,OAAO,CAAC;AAC7D,MAAM,MAAM,OAAO,GAAG,OAAO,aAAa,CAAC,QAAQ,CAAC;AAEpD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;MAMI,CAAC;AACtC,MAAM,MAAM,cAAc,GAAG,OAAO,oBAAoB,CAAC,QAAQ,CAAC;AAElE,eAAO,MAAM,iCAAiC;;;;;;;;;MAU5C,CAAC;AACH,MAAM,MAAM,2BAA2B,GACrC,OAAO,iCAAiC,CAAC,QAAQ,CAAC"}

package/dist/esm/authentication/sessions/schema.js

@@ -1,14 +1,16 @@
 import { type } from 'arktype';
 import { OptionalDatePayloadSchema, OptionalDateSchema, RequiredDatePayloadSchema, RequiredDateSchema, } from '../../common/schema/dates.js';
+import { KSUIDSchema } from '../../common/schema/id.js';
 import { MetadataMapPropertySchema, MetadataPayloadPropertySchema, } from '../../common/schema/metadata.js';
-import { UserIdSchema } from '../../customer/users/schema.js';
+import { UserIdSchema } from '../../customer/schema.js';
 import { StrategyIdSchema, StrategyTypeSchema, } from '../strategies/schema/base.js';
+import { Model } from '../utils.js';
 export const SessionStatus = {
     INITIATED: 'initiated', // Session was created, but no activity has been taken
     AUTHENTICATED: 'authenticated', // Session is authenticated
     PENDING: 'pending', // Session is in the process of authenticating
 };
-export const SessionIdSchema = type.string;
+export const SessionIdSchema = KSUIDSchema(Model.Session.UIDPrefix);
 export const SessionIdPropertySchema = type({
     id: SessionIdSchema,
 });

package/dist/esm/authentication/settings/schema.d.ts

@@ -16,7 +16,7 @@ export declare const SettingsSchema: import("arktype/internal/methods/object.ts"
     }[] | undefined>) | undefined;
     deletedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
     deactivatedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
-    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 SettingsProperties = typeof SettingsSchema.inferIn;
 export type Settings = typeof SettingsSchema.inferOut;

package/dist/esm/authentication/settings/schema.js

@@ -1,6 +1,6 @@
 import { type } from 'arktype';
 import { OptionalDatePayloadSchema, OptionalDateSchema, RequiredDateSchema, } from '../../common/schema/dates.js';
-import { MetadataMapPropertySchema, MetadataPayloadPropertySchema, UpsertMetadataPayloadPropertySchema, } from '../../common/schema/metadata.js';
+import { MetadataMapPropertySchema, MetadataPayloadPropertySchema, UpsertMetadataPropertyPayloadSchema, } from '../../common/schema/metadata.js';
 import { AuthenticationFactorsSchema } from '../factors/schema.js';
 export const SettingsSchema = type({
     factors: AuthenticationFactorsSchema.optional(),
@@ -17,4 +17,4 @@ export const SettingsPayloadSchema = type({
 }).and(MetadataPayloadPropertySchema);
 export const UpsertSettingsPayloadSchema = type({
     factors: AuthenticationFactorsSchema.optional(),
-}).and(UpsertMetadataPayloadPropertySchema);
+}).and(UpsertMetadataPropertyPayloadSchema);

package/dist/esm/authentication/settings/schema.test.d.ts

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

package/dist/esm/authentication/settings/schema.test.d.ts.map

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

package/dist/esm/authentication/settings/schema.test.js

@@ -0,0 +1,71 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { SettingsSchema, SettingsPayloadSchema, UpsertSettingsPayloadSchema, } from './schema.js';
+describe('Authentication Settings - Schema', () => {
+    describe('SettingsSchema', () => {
+        test('should accept minimal settings object', () => {
+            const settings = {
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: {},
+            };
+            const result = SettingsSchema(settings);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should reject missing required dates', () => {
+            const settings = {
+                metadata: {},
+                // missing createdAt, updatedAt
+            };
+            const result = SettingsSchema(settings);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('SettingsPayloadSchema', () => {
+        test('should accept minimal payload', () => {
+            const payload = {
+                metadata: {},
+            };
+            const result = SettingsPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+        test('should accept payload with optional dates', () => {
+            const payload = {
+                updatedAt: new Date().toISOString(),
+                metadata: {},
+            };
+            const result = SettingsPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept empty payload', () => {
+            const payload = {
+            // Schema might have defaults for metadata
+            };
+            const result = SettingsPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+    });
+    describe('UpsertSettingsPayloadSchema', () => {
+        test('should accept empty upsert payload', () => {
+            const payload = {};
+            const result = UpsertSettingsPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+        test('should accept upsert with only metadata', () => {
+            const payload = {
+                metadata: { configVersion: '2.0' },
+            };
+            const result = UpsertSettingsPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should reject invalid factors structure', () => {
+            const payload = {
+                factors: 'invalid-factors',
+            };
+            const result = UpsertSettingsPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+});

package/dist/esm/authentication/strategies/schema/base.d.ts

@@ -26,7 +26,7 @@ export declare const BaseStrategySchema: import("arktype/internal/methods/object
     updatedAt: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
     deletedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
     deactivatedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
-    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 declare const BaseStrategyPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
     id: string;

package/dist/esm/authentication/strategies/schema/base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../../src/authentication/strategies/schema/base.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,YAAY;;;;CAIf,CAAC;AAEX,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC;AAE/E,eAAO,MAAM,cAAc;;;CAGjB,CAAC;AAEX,MAAM,MAAM,iBAAiB,GAC3B,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,OAAO,cAAc,CAAC,CAAC;AAEvD,eAAO,MAAM,gBAAgB,qEAAc,CAAC;AAC5C,MAAM,MAAM,UAAU,GAAG,OAAO,gBAAgB,CAAC,QAAQ,CAAC;AAE1D,eAAO,MAAM,wBAAwB;;MAEnC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,OAAO,wBAAwB,CAAC,QAAQ,CAAC;AAE1E,eAAO,MAAM,oBAAoB,qFAGhC,CAAC;AACF,eAAO,MAAM,kBAAkB,4FAI9B,CAAC;AACF,eAAO,MAAM,mBAAmB,qEAAiB,CAAC;AAOlD,eAAO,MAAM,kBAAkB;;;;;;;;;MAKE,CAAC;AAElC,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;MAKD,CAAC;AAEtC,eAAO,MAAM,+BAA+B;;;;;;;;;MAIP,CAAC;AAEtC,eAAO,MAAM,+BAA+B;;;;;;;;MAGP,CAAC"}
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../../src/authentication/strategies/schema/base.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,YAAY;;;;CAIf,CAAC;AAEX,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC;AAE/E,eAAO,MAAM,cAAc;;;CAGjB,CAAC;AAEX,MAAM,MAAM,iBAAiB,GAC3B,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,OAAO,cAAc,CAAC,CAAC;AAEvD,eAAO,MAAM,gBAAgB,qEAAwC,CAAC;AACtE,MAAM,MAAM,UAAU,GAAG,OAAO,gBAAgB,CAAC,QAAQ,CAAC;AAE1D,eAAO,MAAM,wBAAwB;;MAEnC,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,OAAO,wBAAwB,CAAC,QAAQ,CAAC;AAE1E,eAAO,MAAM,oBAAoB,qFAGhC,CAAC;AACF,eAAO,MAAM,kBAAkB,4FAI9B,CAAC;AACF,eAAO,MAAM,mBAAmB,qEAAiB,CAAC;AAOlD,eAAO,MAAM,kBAAkB;;;;;;;;;MAKE,CAAC;AAElC,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;MAKD,CAAC;AAEtC,eAAO,MAAM,+BAA+B;;;;;;;;;MAIP,CAAC;AAEtC,eAAO,MAAM,+BAA+B;;;;;;;;MAGP,CAAC"}

package/dist/esm/authentication/strategies/schema/base.js

@@ -1,6 +1,8 @@
 import { type } from 'arktype';
 import { OptionalDatePayloadSchema, OptionalDateSchema, RequiredDatePayloadSchema, RequiredDateSchema, } from '../../../common/index.js';
+import { KSUIDSchema } from '../../../common/schema/id.js';
 import { MetadataMapPropertySchema, MetadataPayloadPropertySchema, } from '../../../common/schema/metadata.js';
+import { Model } from '../../utils.js';
 export const StrategyType = {
     EMAIL: 'email',
     PASSWORD: 'password',
@@ -10,7 +12,7 @@ export const StrategyStatus = {
     ENABLED: 'enabled',
     DISABLED: 'disabled',
 };
-export const StrategyIdSchema = type.string;
+export const StrategyIdSchema = KSUIDSchema(Model.Strategy.UIDPrefix);
 export const StrategyIdPropertySchema = type({
     id: StrategyIdSchema,
 });

package/dist/esm/authentication/strategies/schema/schema.d.ts

@@ -161,7 +161,7 @@ export declare const StrategySchema: import("arktype/internal/methods/object.ts"
     updatedAt: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
     deletedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
     deactivatedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
-    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>>;
     type: "email";
 } | {
     id: string;
@@ -171,7 +171,7 @@ export declare const StrategySchema: import("arktype/internal/methods/object.ts"
     updatedAt: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
     deletedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
     deactivatedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
-    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>>;
     type: "password";
     settings: {
         passwordPolicy: {
@@ -191,7 +191,7 @@ export declare const StrategySchema: import("arktype/internal/methods/object.ts"
     updatedAt: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
     deletedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
     deactivatedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
-    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>>;
     type: "totp";
     settings: {
         digits: import("arktype/internal/attributes.ts").Default<6 | 7 | 8, 6>;

package/dist/esm/authentication/strategies/schema/types/email.d.ts

@@ -6,7 +6,7 @@ export declare const EmailStrategySchema: import("arktype/internal/methods/objec
     updatedAt: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
     deletedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
     deactivatedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
-    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>>;
     type: "email";
 }, {}>;
 export type EmailStrategyProperties = typeof EmailStrategySchema.inferIn;

package/dist/esm/authentication/strategies/schema/types/email.test.d.ts

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