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

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.d.ts

@@ -0,0 +1,57 @@
+export declare const AuthenticationFactorSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    nextFactors?: {
+        id: string;
+        nextFactors?: /*elided*/ any[] | null | undefined;
+    }[] | null | undefined;
+}, {}>;
+export type AuthenticationFactorProperties = typeof AuthenticationFactorPayloadSchema.inferIn;
+export type AuthenticationFactor = typeof AuthenticationFactorPayloadSchema.inferOut;
+export declare const AuthenticationFactorPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    nextFactors?: {
+        id: string;
+        nextFactors?: /*elided*/ any[] | null | undefined;
+    }[] | null | undefined;
+}, {}>;
+export type AuthenticationFactorPayload = typeof AuthenticationFactorPayloadSchema.inferOut;
+export declare const AuthenticationFactorsSchema: import("arktype/internal/methods/object.ts").ObjectType<(In: {
+    id: string;
+    nextFactors?: {
+        id: string;
+        nextFactors?: /*elided*/ any[] | null | undefined;
+    }[] | null | undefined;
+}[] | null | undefined) => import("arktype").Out<{
+    id: string;
+    nextFactors?: {
+        id: string;
+        nextFactors?: /*elided*/ any[] | null | undefined;
+    }[] | null | undefined;
+}[] | undefined>, {}>;
+export type AuthenticationFactors = typeof AuthenticationFactorsSchema.inferOut;
+export declare const AuthenticationFactorsPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    factors: (In: {
+        id: string;
+        nextFactors?: {
+            id: string;
+            nextFactors?: /*elided*/ any[] | null | undefined;
+        }[] | null | undefined;
+    }[] | null | undefined) => import("arktype").Out<{
+        id: string;
+        nextFactors?: {
+            id: string;
+            nextFactors?: /*elided*/ any[] | null | undefined;
+        }[] | null | undefined;
+    }[] | undefined>;
+}, {}>;
+export type AuthenticationFactorsPayload = typeof AuthenticationFactorsPayloadSchema.inferOut;
+export declare const UpsertAuthenticationFactorsPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    factors?: {
+        id: string;
+        nextFactors?: {
+            id: string;
+            nextFactors?: /*elided*/ any[] | null | undefined;
+        }[] | null | undefined;
+    }[] | null | undefined;
+}, {}>;
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/authentication/factors/schema.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,0BAA0B;;;;;;MAGrC,CAAC;AACH,MAAM,MAAM,8BAA8B,GACxC,OAAO,iCAAiC,CAAC,OAAO,CAAC;AACnD,MAAM,MAAM,oBAAoB,GAC9B,OAAO,iCAAiC,CAAC,QAAQ,CAAC;AAEpD,eAAO,MAAM,iCAAiC;;;;;;MAG5C,CAAC;AACH,MAAM,MAAM,2BAA2B,GACrC,OAAO,iCAAiC,CAAC,QAAQ,CAAC;AAEpD,eAAO,MAAM,2BAA2B;;;;;;;;;;;;qBAGK,CAAC;AAC9C,MAAM,MAAM,qBAAqB,GAAG,OAAO,2BAA2B,CAAC,QAAQ,CAAC;AAEhF,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;MAE7C,CAAC;AACH,MAAM,MAAM,4BAA4B,GACtC,OAAO,kCAAkC,CAAC,QAAQ,CAAC;AAErD,eAAO,MAAM,wCAAwC;;;;;;;;MAInD,CAAC"}

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

@@ -0,0 +1,29 @@
+import { scope, type } from 'arktype';
+import { StrategyIdSchema } from '../strategies/schema/base.js';
+const factorScope = scope({
+    factor: {
+        id: StrategyIdSchema,
+        'nextFactors?': 'childFactors',
+    },
+    childFactors: 'factor[] | undefined | null',
+    'nextFactors?': 'factor[] | undefined | null',
+});
+export const AuthenticationFactorSchema = type({
+    id: StrategyIdSchema,
+    ...factorScope.export('nextFactors?'),
+});
+export const AuthenticationFactorPayloadSchema = type({
+    id: StrategyIdSchema,
+    ...factorScope.export('nextFactors?'),
+});
+export const AuthenticationFactorsSchema = AuthenticationFactorPayloadSchema.array()
+    .or('undefined | null')
+    .pipe((f) => (f == null ? undefined : f));
+export const AuthenticationFactorsPayloadSchema = type({
+    factors: AuthenticationFactorsSchema,
+});
+export const UpsertAuthenticationFactorsPayloadSchema = type({
+    factors: AuthenticationFactorPayloadSchema.array()
+        .or('undefined | null')
+        .optional(),
+});

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

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

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

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

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

@@ -0,0 +1,122 @@
+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', () => {
+        test('should parse response payload successfully', async () => {
+            expect(AuthenticationFactorsPayloadSchema({
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                factors: [
+                    {
+                        id: generateStrategyId(),
+                    },
+                ],
+            })).not.toBeInstanceOf(type.errors);
+            // Undefined factors
+            expect(AuthenticationFactorsPayloadSchema({
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                factors: undefined,
+            })).not.toBeInstanceOf(type.errors);
+        });
+        test('should parse upsert payload successfully', async () => {
+            expect(UpsertAuthenticationFactorsPayloadSchema({
+                factors: [
+                    {
+                        id: generateStrategyId(),
+                    },
+                ],
+            })).not.toBeInstanceOf(type.errors);
+            // Null factors
+            expect(UpsertAuthenticationFactorsPayloadSchema({
+                factors: null,
+            })).not.toBeInstanceOf(type.errors);
+            // Undefined factors
+            expect(UpsertAuthenticationFactorsPayloadSchema({
+                factors: undefined,
+            })).not.toBeInstanceOf(type.errors);
+        });
+        test('should throw error for invalid factors', async () => {
+            // Factor object
+            expect(AuthenticationFactorsPayloadSchema({
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                factors: { id: generateStrategyId() },
+            })).toBeInstanceOf(type.errors);
+            // Factor array of string
+            expect(AuthenticationFactorsPayloadSchema({
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                factors: [generateStrategyId()],
+            })).toBeInstanceOf(type.errors);
+        });
+        test('should accept various next factors types', async () => {
+            // Undefined
+            expect(AuthenticationFactorPayloadSchema({
+                id: generateStrategyId(),
+                nextFactors: undefined,
+            })).not.toBeInstanceOf(type.errors);
+            // Array
+            expect(AuthenticationFactorPayloadSchema({
+                id: generateStrategyId(),
+                nextFactors: [
+                    {
+                        id: generateStrategyId(),
+                    },
+                ],
+            })).not.toBeInstanceOf(type.errors);
+            // Deeply nested array
+            expect(AuthenticationFactorPayloadSchema({
+                id: generateStrategyId(),
+                nextFactors: [
+                    {
+                        id: generateStrategyId(),
+                        nextFactors: [
+                            {
+                                id: generateStrategyId(),
+                                nextFactors: [
+                                    {
+                                        id: generateStrategyId(),
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            })).not.toBeInstanceOf(type.errors);
+        });
+        test('should throw error for invalid factor id', async () => {
+            // Number
+            expect(AuthenticationFactorsPayloadSchema({
+                id: generateStrategyId(),
+            })).toBeInstanceOf(type.errors);
+            // Null
+            expect(AuthenticationFactorsPayloadSchema({
+                id: null,
+            })).toBeInstanceOf(type.errors);
+            // Undefined
+            expect(AuthenticationFactorsPayloadSchema({
+                id: undefined,
+            })).toBeInstanceOf(type.errors);
+        });
+        test('should throw error for invalid next factors', async () => {
+            // String
+            expect(AuthenticationFactorsPayloadSchema({
+                id: generateStrategyId(),
+                nextFactors: generateStrategyId(),
+            })).toBeInstanceOf(type.errors);
+            // Object
+            expect(AuthenticationFactorsPayloadSchema({
+                id: generateStrategyId(),
+                nextFactors: { id: generateStrategyId() },
+            })).toBeInstanceOf(type.errors);
+            // Array
+            expect(AuthenticationFactorsPayloadSchema({
+                id: generateStrategyId(),
+                nextFactors: [generateStrategyId()],
+            })).toBeInstanceOf(type.errors);
+        });
+    });
+});

package/dist/esm/authentication/index.d.ts

@@ -0,0 +1,10 @@
+export * from './utils.js';
+export * from './factors/schema.js';
+export * from './providers/schema.js';
+export * from './sessions/resources.js';
+export * from './sessions/schema.js';
+export * from './settings/resources.js';
+export * from './settings/schema.js';
+export * from './strategies/resources.js';
+export * from './strategies/schema/schema.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/authentication/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/authentication/index.ts"],"names":[],"mappings":"AACA,cAAc,YAAY,CAAC;AAG3B,cAAc,qBAAqB,CAAC;AAGpC,cAAc,uBAAuB,CAAC;AAGtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AAGrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AAGrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,+BAA+B,CAAC"}

package/dist/esm/authentication/index.js

@@ -0,0 +1,15 @@
+// Common
+export * from './utils.js';
+// Factors
+export * from './factors/schema.js';
+// Providers
+export * from './providers/schema.js';
+// Session
+export * from './sessions/resources.js';
+export * from './sessions/schema.js';
+// Settings
+export * from './settings/resources.js';
+export * from './settings/schema.js';
+// Strategies
+export * from './strategies/resources.js';
+export * from './strategies/schema/schema.js';

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

@@ -0,0 +1,27 @@
+export declare const ProviderType: {
+    readonly MONDO: "mondo";
+};
+export type AnyProviderType = (typeof ProviderType)[keyof typeof ProviderType];
+export declare const ProviderIdSchema: import("arktype/internal/methods/string.ts").StringType<string, {}>;
+export type ProviderId = typeof ProviderIdSchema.inferOut;
+export declare const ProviderIdPropertySchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+}, {}>;
+export type ProviderIdProperty = typeof ProviderIdPropertySchema.inferOut;
+export declare const ProviderTypeSchema: import("arktype/internal/methods/string.ts").StringType<"mondo", {}>;
+export declare const ProviderPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    type: "mondo";
+    user: string;
+    strategy: string;
+    updatedAt: (In: string | Date) => import("arktype").Out<string>;
+    deletedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
+    deactivatedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
+    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 ProviderPayload = typeof ProviderPayloadSchema.inferOut;
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/authentication/providers/schema.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,YAAY;;CAEf,CAAC;AAEX,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC;AAE/E,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,kBAAkB,sEAAsC,CAAC;AAEtE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;MAOG,CAAC;AACtC,MAAM,MAAM,eAAe,GAAG,OAAO,qBAAqB,CAAC,QAAQ,CAAC"}

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

@@ -0,0 +1,21 @@
+import { type } from 'arktype';
+import { OptionalDatePayloadSchema, RequiredDatePayloadSchema, } from '../../common/schema/dates.js';
+import { MetadataPayloadPropertySchema } from '../../common/schema/metadata.js';
+import { UserIdSchema } from '../../customer/schema.js';
+import { StrategyIdSchema } from '../strategies/schema/base.js';
+export const ProviderType = {
+    MONDO: 'mondo',
+};
+export const ProviderIdSchema = type.string;
+export const ProviderIdPropertySchema = type({
+    id: ProviderIdSchema,
+});
+export const ProviderTypeSchema = type.enumerated(ProviderType.MONDO);
+export const ProviderPayloadSchema = ProviderIdPropertySchema.and({
+    type: ProviderTypeSchema,
+    user: UserIdSchema,
+    strategy: StrategyIdSchema,
+    updatedAt: RequiredDatePayloadSchema,
+    'deletedAt?': OptionalDatePayloadSchema,
+    'deactivatedAt?': OptionalDatePayloadSchema,
+}).and(MetadataPayloadPropertySchema);

package/dist/esm/authentication/resources.d.ts

@@ -0,0 +1,2 @@
+export declare const PATH = "/v1/authentication";
+//# sourceMappingURL=resources.d.ts.map

package/dist/esm/authentication/resources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../../src/authentication/resources.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,IAAI,uBAAuB,CAAC"}

package/dist/esm/authentication/resources.js

@@ -0,0 +1 @@
+export const PATH = '/v1/authentication';

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

@@ -0,0 +1,21 @@
+import type { MondoIdentity } from '../../common/resources/init.js';
+import { type PaginationCollection } from '../../common/schema/collection.js';
+import type { Pagination } from '../../common/schema/pagination.js';
+import { type Session } from './schema.js';
+export type SessionListingOptions = {
+    filter?: {
+        user?: string;
+        app?: string;
+    };
+};
+export declare class SessionResources {
+    private readonly instance;
+    constructor(instance: MondoIdentity);
+    static buildPath(id: string): string;
+    static buildListingPath(options?: SessionListingOptions): string;
+    listItems(options?: SessionListingOptions, pagination?: Pagination): Promise<PaginationCollection<Session>>;
+    deleteItem(id: string): Promise<Session>;
+}
+export declare function listSessions(instance: MondoIdentity, options?: SessionListingOptions, pagination?: Pagination): Promise<PaginationCollection<Session>>;
+export declare function deleteSession(instance: MondoIdentity, id: string): Promise<Session>;
+//# sourceMappingURL=resources.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../../../src/authentication/sessions/resources.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AASpE,OAAO,EACL,KAAK,oBAAoB,EAE1B,MAAM,mCAAmC,CAAC;AAC3C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAC;AAGpE,OAAO,EAAE,KAAK,OAAO,EAAiB,MAAM,aAAa,CAAC;AAI1D,MAAM,MAAM,qBAAqB,GAAG;IAClC,MAAM,CAAC,EAAE;QACP,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,GAAG,CAAC,EAAE,MAAM,CAAC;KACd,CAAC;CACH,CAAC;AAEF,qBAAa,gBAAgB;IACR,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,aAAa;IAE3D,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAQpC,MAAM,CAAC,gBAAgB,CAAC,OAAO,CAAC,EAAE,qBAAqB,GAAG,MAAM;IAYzD,SAAS,CACd,OAAO,CAAC,EAAE,qBAAqB,EAC/B,UAAU,CAAC,EAAE,UAAU,GACtB,OAAO,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC;IAIlC,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;CAGhD;AAED,wBAAsB,YAAY,CAChC,QAAQ,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,qBAAqB,EAC/B,UAAU,CAAC,EAAE,UAAU,GACtB,OAAO,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC,CAWxC;AAED,wBAAsB,aAAa,CACjC,QAAQ,EAAE,aAAa,EACvB,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,OAAO,CAAC,CASlB"}

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

@@ -0,0 +1,37 @@
+import { deleteItemWithAuthorization, getItemWithAuthorization, } from '../../common/resources/operations.js';
+import { addPaginationToURL, parseEgressSchema, } from '../../common/resources/utils.js';
+import { PaginationCollectionSchema, } from '../../common/schema/collection.js';
+import { appendSearchParams } from '../../common/schema/url.js';
+import { PATH } from '../resources.js';
+import { SessionSchema } from './schema.js';
+const RESOURCE = 'sessions';
+export class SessionResources {
+    instance;
+    constructor(instance) {
+        this.instance = instance;
+    }
+    static buildPath(id) {
+        if (id.startsWith(PATH)) {
+            return id;
+        }
+        return [PATH, RESOURCE, id].filter(Boolean).join('/');
+    }
+    static buildListingPath(options) {
+        return appendSearchParams([PATH, RESOURCE].filter(Boolean).join('/'), new Map(
+        // format the the keys to 'filter[<key>]'
+        Array.from(Object.entries(options?.filter || {})).map(([key, value]) => [`filter[${key}]`, value])));
+    }
+    listItems(options, pagination) {
+        return listSessions(this.instance, options, pagination);
+    }
+    deleteItem(id) {
+        return deleteSession(this.instance, id);
+    }
+}
+export async function listSessions(instance, options, pagination) {
+    const url = addPaginationToURL(new URL(SessionResources.buildListingPath(options), instance.config.host), pagination);
+    return parseEgressSchema(PaginationCollectionSchema(SessionSchema)(await getItemWithAuthorization(url, instance.authorizer)));
+}
+export async function deleteSession(instance, id) {
+    return parseEgressSchema(SessionSchema(await deleteItemWithAuthorization(new URL(SessionResources.buildPath(id), instance.config.host), instance.authorizer)));
+}

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

@@ -0,0 +1,81 @@
+export declare const SessionStatus: {
+    readonly INITIATED: "initiated";
+    readonly AUTHENTICATED: "authenticated";
+    readonly PENDING: "pending";
+};
+export type AnySessionStatus = (typeof SessionStatus)[keyof typeof SessionStatus];
+export declare const SessionIdSchema: import("arktype/internal/methods/string.ts").StringType<string, {}>;
+export type SessionId = typeof SessionIdSchema.inferOut;
+export declare const SessionIdPropertySchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+}, {}>;
+export type SessionIdProperty = typeof SessionIdPropertySchema.inferOut;
+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";
+    settings?: Record<string, unknown> | undefined;
+    state?: string | undefined;
+}, {}>;
+export type SessionAuthenticationFactor = typeof SessionAuthenticationFactorSchema.inferOut;
+export declare const SessionAuthenticationFactorHistorySchema: import("arktype/internal/methods/object.ts").ObjectType<(In: string[] | Set<string> | undefined) => import("arktype").Out<string[] | Set<string> | undefined>, {}>;
+export type SessionAuthenticationFactorHistory = typeof SessionAuthenticationFactorHistorySchema.inferOut;
+export declare const SessionSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    status: "pending" | "initiated" | "authenticated";
+    user?: string | undefined;
+    userAgent?: string | undefined;
+    sourceIp?: string | undefined;
+    factors?: {
+        id: string;
+        type: "email" | "password" | "totp";
+        settings?: Record<string, unknown> | undefined;
+        state?: string | undefined;
+    }[] | undefined;
+    factorHistory?: ((In: string[] | Set<string> | undefined) => import("arktype").Out<string[] | Set<string> | undefined>) | undefined;
+    expiresAt: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
+    createdAt: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
+    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>>;
+}, {}>;
+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: "pending" | "initiated" | "authenticated";
+    user?: string | undefined;
+    userAgent?: string | undefined;
+    sourceIp?: string | undefined;
+    factors?: {
+        id: string;
+        type: "email" | "password" | "totp";
+        settings?: Record<string, unknown> | undefined;
+        state?: string | undefined;
+    }[] | undefined;
+    factorHistory?: ((In: string[] | Set<string> | undefined) => import("arktype").Out<string[] | Set<string> | undefined>) | undefined;
+    expiresAt: (In: string | Date) => import("arktype").Out<string>;
+    createdAt: (In: string | Date) => import("arktype").Out<string>;
+    updatedAt: (In: string | Date) => import("arktype").Out<string>;
+    deletedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
+    deactivatedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
+    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 SessionPayload = typeof SessionPayloadSchema.inferOut;
+export declare const SessionAssociationReferenceSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    status: "pending" | "initiated" | "authenticated";
+    user?: string | undefined;
+    userAgent?: string | undefined;
+    sourceIp?: string | undefined;
+    expiresAt: (In: string | Date) => import("arktype").Out<string>;
+    createdAt: (In: string | Date) => import("arktype").Out<string>;
+    model: "Session";
+}, {}>;
+export type SessionAssociationReference = typeof SessionAssociationReferenceSchema.inferOut;
+//# sourceMappingURL=schema.d.ts.map

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

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

@@ -0,0 +1,54 @@
+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/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 = KSUIDSchema(Model.Session.UIDPrefix);
+export const SessionIdPropertySchema = type({
+    id: SessionIdSchema,
+});
+export const SessionStatusSchema = type.enumerated(SessionStatus.INITIATED, SessionStatus.AUTHENTICATED, SessionStatus.PENDING);
+export const SessionAuthenticationFactorSchema = type({
+    id: StrategyIdSchema,
+    type: StrategyTypeSchema,
+    settings: type('Record<string, unknown> | undefined').optional(),
+    state: type('string | undefined').optional(),
+});
+const AuthenticationFactorHistoryArraySchema = StrategyIdSchema.array();
+const AuthenticationFactorHistorySetSchema = type.instanceOf((Set));
+export const SessionAuthenticationFactorHistorySchema = type('undefined')
+    .or(AuthenticationFactorHistoryArraySchema)
+    .or(AuthenticationFactorHistorySetSchema)
+    .pipe((s) => (s instanceof Set ? Array.from(s) : s)?.length ? s : undefined);
+const BaseSchema = SessionIdPropertySchema.and({
+    status: SessionStatusSchema,
+    user: UserIdSchema.or('undefined').optional(),
+    userAgent: type('string | undefined').optional(),
+    sourceIp: type('string.ip.v4 | string.ip.v6	| undefined').optional(),
+    factors: SessionAuthenticationFactorSchema.array().or('undefined').optional(),
+    factorHistory: SessionAuthenticationFactorHistorySchema.optional(),
+});
+export const SessionSchema = BaseSchema.and({
+    expiresAt: RequiredDateSchema,
+    createdAt: RequiredDateSchema,
+    updatedAt: RequiredDateSchema,
+    deletedAt: OptionalDateSchema.optional(),
+    deactivatedAt: OptionalDateSchema.optional(),
+}).and(MetadataMapPropertySchema);
+export const SessionPayloadSchema = BaseSchema.and({
+    expiresAt: RequiredDatePayloadSchema,
+    createdAt: RequiredDatePayloadSchema,
+    updatedAt: RequiredDatePayloadSchema,
+    'deletedAt?': OptionalDatePayloadSchema,
+    'deactivatedAt?': OptionalDatePayloadSchema,
+}).and(MetadataPayloadPropertySchema);
+export const SessionAssociationReferenceSchema = SessionPayloadSchema.pick('id', 'status', 'user', 'userAgent', 'sourceIp', 'createdAt', 'expiresAt').and({
+    model: "'Session'",
+});