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

package/dist/esm/app/oauth/resources.js

@@ -0,0 +1,29 @@
+import { getItemWithAuthorization, insertItemWithAuthorization, } from '../../common/resources/operations.js';
+import { parseEgressSchema } from '../../common/resources/utils.js';
+import { PATH } from '../resources.js';
+import { InsertOAuthPayloadSchema, OAuthSchema, } from './schema.js';
+const RESOURCE = 'oauth';
+export class OAuthResources {
+    instance;
+    constructor(instance) {
+        this.instance = instance;
+    }
+    static buildPath(appId) {
+        if (appId?.startsWith(PATH)) {
+            return appId;
+        }
+        return [PATH, appId, RESOURCE].filter(Boolean).join('/');
+    }
+    getItem(id) {
+        return getOAuth(this.instance, id);
+    }
+    rotateItemSecret(id) {
+        return rotateOAuthSecret(this.instance, id);
+    }
+}
+export async function getOAuth(instance, appId) {
+    return parseEgressSchema(OAuthSchema(await getItemWithAuthorization(new URL(OAuthResources.buildPath(appId), instance.config.host), instance.authorizer)));
+}
+export async function rotateOAuthSecret(instance, appId, item) {
+    return parseEgressSchema(OAuthSchema(await insertItemWithAuthorization(new URL(OAuthResources.buildPath(appId), instance.config.host), instance.authorizer, parseEgressSchema(InsertOAuthPayloadSchema.onUndeclaredKey('delete')(item)))));
+}

package/dist/esm/app/oauth/schema.d.ts

@@ -0,0 +1,42 @@
+export declare const OAuthIdSchema: import("arktype/internal/methods/string.ts").StringType<string, {}>;
+export type OAuthId = typeof OAuthIdSchema.inferOut;
+export declare const OAuthIdPropertySchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+}, {}>;
+export type OAuthIdProperty = typeof OAuthIdPropertySchema.inferOut;
+export declare const OAuthSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    clientId: string;
+    clientSecret: string;
+    updatedAt?: 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>>;
+}, {}>;
+export type OAuthProperties = typeof OAuthSchema.inferIn;
+export type OAuth = typeof OAuthSchema.inferOut;
+export declare const OAuthPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: string;
+    clientId: string;
+    clientSecret: string;
+    updatedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
+    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 OAuthPayload = typeof OAuthPayloadSchema.inferOut;
+export declare const InsertOAuthPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    id: import("arktype/internal/attributes.ts").Default<string, string>;
+    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 InsertOAuthInput = typeof InsertOAuthPayloadSchema.inferIn;
+export type InsertOAuthPayload = typeof InsertOAuthPayloadSchema.inferOut;
+//# sourceMappingURL=schema.d.ts.map

package/dist/esm/app/oauth/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/app/oauth/schema.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,aAAa,qEAAqC,CAAC;AAChE,MAAM,MAAM,OAAO,GAAG,OAAO,aAAa,CAAC,QAAQ,CAAC;AAEpD,eAAO,MAAM,qBAAqB;;MAEhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,OAAO,qBAAqB,CAAC,QAAQ,CAAC;AAOpE,eAAO,MAAM,WAAW;;;;;;;;MAIS,CAAC;AAClC,MAAM,MAAM,eAAe,GAAG,OAAO,WAAW,CAAC,OAAO,CAAC;AACzD,MAAM,MAAM,KAAK,GAAG,OAAO,WAAW,CAAC,QAAQ,CAAC;AAEhD,eAAO,MAAM,kBAAkB;;;;;;;;;;;;MAIM,CAAC;AACtC,MAAM,MAAM,YAAY,GAAG,OAAO,kBAAkB,CAAC,QAAQ,CAAC;AAE9D,eAAO,MAAM,wBAAwB;;;;;;;MAEA,CAAC;AACtC,MAAM,MAAM,gBAAgB,GAAG,OAAO,wBAAwB,CAAC,OAAO,CAAC;AACvE,MAAM,MAAM,kBAAkB,GAAG,OAAO,wBAAwB,CAAC,QAAQ,CAAC"}

package/dist/esm/app/oauth/schema.js

@@ -0,0 +1,26 @@
+import { type } from 'arktype';
+import { OptionalDatePayloadSchema, OptionalDateSchema, } from '../../common/schema/dates.js';
+import { KSUIDSchema } from '../../common/schema/id.js';
+import { MetadataMapPropertySchema, MetadataPayloadPropertySchema, } from '../../common/schema/metadata.js';
+import { Model, generateOAuthId } from '../utils.js';
+export const OAuthIdSchema = KSUIDSchema(Model.OAuth.UIDPrefix);
+export const OAuthIdPropertySchema = type({
+    id: OAuthIdSchema,
+});
+const BaseOAuth = OAuthIdPropertySchema.and({
+    clientId: type('string'),
+    clientSecret: type('string'),
+});
+export const OAuthSchema = BaseOAuth.and({
+    'updatedAt?': OptionalDateSchema,
+    'deletedAt?': OptionalDateSchema,
+    'deactivatedAt?': OptionalDateSchema,
+}).and(MetadataMapPropertySchema);
+export const OAuthPayloadSchema = BaseOAuth.and({
+    'updatedAt?': OptionalDatePayloadSchema,
+    'deletedAt?': OptionalDatePayloadSchema,
+    'deactivatedAt?': OptionalDatePayloadSchema,
+}).and(MetadataPayloadPropertySchema);
+export const InsertOAuthPayloadSchema = type({
+    id: OAuthIdSchema.default(() => generateOAuthId()),
+}).and(MetadataPayloadPropertySchema);

package/dist/esm/app/oauth/schema.test.d.ts

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

package/dist/esm/app/oauth/schema.test.d.ts.map

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

package/dist/esm/app/oauth/schema.test.js

@@ -0,0 +1,171 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { generateOAuthId } from '../utils.js';
+import { InsertOAuthPayloadSchema, OAuthIdPropertySchema, OAuthIdSchema, OAuthPayloadSchema, OAuthSchema, } from './schema.js';
+describe('App OAuth - Schema', () => {
+    describe('OAuthIdSchema', () => {
+        test('should accept valid OAuth ID', () => {
+            const id = generateOAuthId();
+            const result = OAuthIdSchema(id);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toBe(id);
+        });
+        test('should reject invalid OAuth ID format', () => {
+            expect(OAuthIdSchema('invalid_id')).toBeInstanceOf(type.errors);
+            expect(OAuthIdSchema('wrong_prefix_123')).toBeInstanceOf(type.errors);
+        });
+        test('should reject non-string values', () => {
+            expect(OAuthIdSchema(123)).toBeInstanceOf(type.errors);
+            expect(OAuthIdSchema(null)).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('OAuthIdPropertySchema', () => {
+        test('should accept valid id property', () => {
+            const payload = { id: generateOAuthId() };
+            const result = OAuthIdPropertySchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+        test('should reject missing id', () => {
+            const result = OAuthIdPropertySchema({});
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject invalid id format', () => {
+            const result = OAuthIdPropertySchema({ id: 'invalid_id' });
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('OAuthSchema', () => {
+        test('should accept complete OAuth object', () => {
+            const oauth = {
+                id: generateOAuthId(),
+                clientId: 'client_12345',
+                clientSecret: 'secret_abcdef',
+                updatedAt: new Date(),
+                metadata: { key: 'value' },
+            };
+            const result = OAuthSchema(oauth);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept minimal OAuth object', () => {
+            const oauth = {
+                id: generateOAuthId(),
+                clientId: 'simple_client',
+                clientSecret: 'simple_secret',
+                metadata: {},
+            };
+            const result = OAuthSchema(oauth);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept OAuth with optional dates', () => {
+            const oauth = {
+                id: generateOAuthId(),
+                clientId: 'test_client',
+                clientSecret: 'test_secret',
+                updatedAt: new Date(),
+                deletedAt: new Date(),
+                deactivatedAt: new Date(),
+                metadata: {},
+            };
+            const result = OAuthSchema(oauth);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should reject missing required fields', () => {
+            const oauth = {
+                id: generateOAuthId(),
+                // missing clientId, clientSecret, metadata
+            };
+            const result = OAuthSchema(oauth);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject empty client credentials', () => {
+            const oauth = {
+                id: generateOAuthId(),
+                clientId: '',
+                clientSecret: '',
+                metadata: {},
+            };
+            const result = OAuthSchema(oauth);
+            expect(result).not.toBeInstanceOf(type.errors); // Empty strings are valid strings
+        });
+    });
+    describe('OAuthPayloadSchema', () => {
+        test('should accept complete payload', () => {
+            const payload = {
+                id: generateOAuthId(),
+                clientId: 'payload_client',
+                clientSecret: 'payload_secret',
+                updatedAt: new Date().toISOString(),
+                deletedAt: new Date().toISOString(),
+                deactivatedAt: new Date().toISOString(),
+                metadata: { version: '1.0' },
+            };
+            const result = OAuthPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+        test('should accept minimal payload', () => {
+            const payload = {
+                id: generateOAuthId(),
+                clientId: 'min_client',
+                clientSecret: 'min_secret',
+                metadata: {},
+            };
+            const result = OAuthPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+        test('should accept payload with optional dates', () => {
+            const payload = {
+                id: generateOAuthId(),
+                clientId: 'client_with_dates',
+                clientSecret: 'secret_with_dates',
+                updatedAt: new Date().toISOString(),
+                metadata: {},
+            };
+            const result = OAuthPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should reject missing required fields', () => {
+            const payload = {
+                id: generateOAuthId(),
+                // missing clientId, clientSecret, metadata
+            };
+            const result = OAuthPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('InsertOAuthPayloadSchema', () => {
+        test('should accept complete insert payload', () => {
+            const payload = {
+                id: generateOAuthId(),
+                metadata: { source: 'manual' },
+            };
+            const result = InsertOAuthPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+        test('should accept minimal insert payload', () => {
+            const payload = {};
+            const result = InsertOAuthPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            // Should generate default ID
+            expect(result.id).toMatch(/^aoa_/);
+        });
+        test('should generate default ID when not provided', () => {
+            const payload = {
+                metadata: { auto: true },
+            };
+            const result = InsertOAuthPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result.id).toMatch(/^aoa_/);
+        });
+        test('should accept payload with only metadata', () => {
+            const payload = {
+                metadata: { test: 'value' },
+            };
+            const result = InsertOAuthPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+    });
+});

package/dist/esm/app/oidc/resources.d.ts

@@ -0,0 +1,16 @@
+import type { MondoIdentity } from '../../common/resources/init.js';
+import { type InsertOIDCInput, type OIDC, type UpdateOIDCInput } from './schema.js';
+export declare class OIDCResources {
+    private readonly instance;
+    constructor(instance: MondoIdentity);
+    static buildPath(appId: string): string;
+    getItem(appId: string): Promise<OIDC>;
+    insertItem(appId: string, item?: InsertOIDCInput): Promise<OIDC>;
+    updateItem(appId: string, item: UpdateOIDCInput): Promise<OIDC>;
+    deleteItem(appId: string): Promise<OIDC>;
+}
+export declare function getOIDC(instance: MondoIdentity, appId: string): Promise<OIDC>;
+export declare function insertOIDC(instance: MondoIdentity, appId: string, item?: InsertOIDCInput): Promise<OIDC>;
+export declare function updateOIDC(instance: MondoIdentity, appId: string, item: UpdateOIDCInput): Promise<OIDC>;
+export declare function deleteOIDC(instance: MondoIdentity, appId: string): Promise<OIDC>;
+//# sourceMappingURL=resources.d.ts.map

package/dist/esm/app/oidc/resources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../../../src/app/oidc/resources.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AASpE,OAAO,EACL,KAAK,eAAe,EAEpB,KAAK,IAAI,EAET,KAAK,eAAe,EAErB,MAAM,aAAa,CAAC;AAIrB,qBAAa,aAAa;IACL,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,aAAa;IAE3D,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAQhC,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIrC,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAIhE,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAI/D,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAGhD;AAED,wBAAsB,OAAO,CAC3B,QAAQ,EAAE,aAAa,EACvB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,CAAC,CASf;AAED,wBAAsB,UAAU,CAC9B,QAAQ,EAAE,aAAa,EACvB,KAAK,EAAE,MAAM,EACb,IAAI,CAAC,EAAE,eAAe,GACrB,OAAO,CAAC,IAAI,CAAC,CAYf;AAED,wBAAsB,UAAU,CAC9B,QAAQ,EAAE,aAAa,EACvB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,eAAe,GACpB,OAAO,CAAC,IAAI,CAAC,CAYf;AAED,wBAAsB,UAAU,CAC9B,QAAQ,EAAE,aAAa,EACvB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,CAAC,CASf"}

package/dist/esm/app/oidc/resources.js

@@ -0,0 +1,41 @@
+import { deleteItemWithAuthorization, getItemWithAuthorization, insertItemWithAuthorization, updateItemWithAuthorization, } from '../../common/resources/operations.js';
+import { parseEgressSchema } from '../../common/resources/utils.js';
+import { PATH } from '../resources.js';
+import { InsertOIDCPayloadSchema, OIDCSchema, UpdateOIDCPayloadSchema, } from './schema.js';
+const RESOURCE = 'oidc';
+export class OIDCResources {
+    instance;
+    constructor(instance) {
+        this.instance = instance;
+    }
+    static buildPath(appId) {
+        if (appId?.startsWith(PATH)) {
+            return appId;
+        }
+        return [PATH, appId, RESOURCE].filter(Boolean).join('/');
+    }
+    getItem(appId) {
+        return getOIDC(this.instance, appId);
+    }
+    insertItem(appId, item) {
+        return insertOIDC(this.instance, appId, item);
+    }
+    updateItem(appId, item) {
+        return updateOIDC(this.instance, appId, item);
+    }
+    deleteItem(appId) {
+        return deleteOIDC(this.instance, appId);
+    }
+}
+export async function getOIDC(instance, appId) {
+    return parseEgressSchema(OIDCSchema(await getItemWithAuthorization(new URL(OIDCResources.buildPath(appId), instance.config.host), instance.authorizer)));
+}
+export async function insertOIDC(instance, appId, item) {
+    return parseEgressSchema(OIDCSchema(await insertItemWithAuthorization(new URL(OIDCResources.buildPath(appId), instance.config.host), instance.authorizer, parseEgressSchema(InsertOIDCPayloadSchema.onUndeclaredKey('delete')(item)))));
+}
+export async function updateOIDC(instance, appId, item) {
+    return parseEgressSchema(OIDCSchema(await updateItemWithAuthorization(new URL(OIDCResources.buildPath(appId), instance.config.host), instance.authorizer, parseEgressSchema(UpdateOIDCPayloadSchema.onUndeclaredKey('delete')(item)))));
+}
+export async function deleteOIDC(instance, appId) {
+    return parseEgressSchema(OIDCSchema(await deleteItemWithAuthorization(new URL(OIDCResources.buildPath(appId), instance.config.host), instance.authorizer)));
+}

package/dist/esm/app/oidc/schema.d.ts

@@ -0,0 +1,38 @@
+export declare const OIDCSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    updatedAt?: 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>>;
+}, {}>;
+export type OIDCProperties = typeof OIDCSchema.inferIn;
+export type OIDC = typeof OIDCSchema.inferOut;
+export declare const OIDCPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    updatedAt?: ((In: string | Date | undefined) => import("arktype").Out<string | undefined>) | undefined;
+    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 OIDCPayload = typeof OIDCPayloadSchema.inferOut;
+export declare const InsertOIDCPayloadSchema: import("arktype").BaseType<{
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
+        [x: string]: string | number | boolean;
+    } | null>) | undefined;
+} | undefined, {}>;
+export type InsertOIDCInput = typeof InsertOIDCPayloadSchema.inferIn;
+export type InsertOIDCPayload = typeof InsertOIDCPayloadSchema.inferOut;
+export declare const UpdateOIDCPayloadSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    metadata?: ((In: {
+        [x: string]: string | number | boolean;
+    } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
+        [x: string]: string | number | boolean;
+    } | undefined>) | undefined;
+}, {}>;
+export type UpdateOIDCInput = typeof UpdateOIDCPayloadSchema.inferIn;
+export type UpdateOIDCPayload = typeof UpdateOIDCPayloadSchema.inferOut;
+//# sourceMappingURL=schema.d.ts.map

package/dist/esm/app/oidc/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/app/oidc/schema.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,UAAU;;;;;MAIU,CAAC;AAClC,MAAM,MAAM,cAAc,GAAG,OAAO,UAAU,CAAC,OAAO,CAAC;AACvD,MAAM,MAAM,IAAI,GAAG,OAAO,UAAU,CAAC,QAAQ,CAAC;AAE9C,eAAO,MAAM,iBAAiB;;;;;;;;;MAIO,CAAC;AACtC,MAAM,MAAM,WAAW,GAAG,OAAO,iBAAiB,CAAC,QAAQ,CAAC;AAE5D,eAAO,MAAM,uBAAuB;;;;;;kBACiB,CAAC;AACtD,MAAM,MAAM,eAAe,GAAG,OAAO,uBAAuB,CAAC,OAAO,CAAC;AACrE,MAAM,MAAM,iBAAiB,GAAG,OAAO,uBAAuB,CAAC,QAAQ,CAAC;AAExE,eAAO,MAAM,uBAAuB;;;;;;MAAgC,CAAC;AACrE,MAAM,MAAM,eAAe,GAAG,OAAO,uBAAuB,CAAC,OAAO,CAAC;AACrE,MAAM,MAAM,iBAAiB,GAAG,OAAO,uBAAuB,CAAC,QAAQ,CAAC"}

package/dist/esm/app/oidc/schema.js

@@ -0,0 +1,15 @@
+import { type } from 'arktype';
+import { OptionalDatePayloadSchema, OptionalDateSchema, } from '../../common/schema/dates.js';
+import { MetadataMapPropertySchema, MetadataPayloadPropertySchema, UpsertMetadataPropertyPayloadSchema, } from '../../common/schema/metadata.js';
+export const OIDCSchema = type({
+    'updatedAt?': OptionalDateSchema,
+    'deletedAt?': OptionalDateSchema,
+    'deactivatedAt?': OptionalDateSchema,
+}).and(MetadataMapPropertySchema);
+export const OIDCPayloadSchema = type({
+    'updatedAt?': OptionalDatePayloadSchema,
+    'deletedAt?': OptionalDatePayloadSchema,
+    'deactivatedAt?': OptionalDatePayloadSchema,
+}).and(MetadataPayloadPropertySchema);
+export const InsertOIDCPayloadSchema = UpsertMetadataPropertyPayloadSchema.or('undefined');
+export const UpdateOIDCPayloadSchema = MetadataPayloadPropertySchema;

package/dist/esm/app/oidc/schema.test.d.ts

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

package/dist/esm/app/oidc/schema.test.d.ts.map

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

package/dist/esm/app/oidc/schema.test.js

@@ -0,0 +1,93 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { InsertOIDCPayloadSchema, OIDCPayloadSchema, OIDCSchema, UpdateOIDCPayloadSchema, } from './schema.js';
+describe('App OIDC - Schema', () => {
+    describe('OIDCSchema', () => {
+        test('should accept complete OIDC object', () => {
+            const oidc = {
+                updatedAt: new Date(),
+                deletedAt: new Date(),
+                deactivatedAt: new Date(),
+                metadata: { provider: 'auth0' },
+            };
+            const result = OIDCSchema(oidc);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept minimal OIDC object', () => {
+            const oidc = {
+                metadata: {},
+            };
+            const result = OIDCSchema(oidc);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept OIDC with only some optional dates', () => {
+            const oidc = {
+                updatedAt: new Date(),
+                metadata: { configured: true },
+            };
+            const result = OIDCSchema(oidc);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+    });
+    describe('OIDCPayloadSchema', () => {
+        test('should accept complete payload', () => {
+            const payload = {
+                updatedAt: new Date().toISOString(),
+                deletedAt: new Date().toISOString(),
+                deactivatedAt: new Date().toISOString(),
+                metadata: { issuer: 'https://auth.example.com' },
+            };
+            const result = OIDCPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+        test('should accept minimal payload', () => {
+            const payload = {
+                metadata: {},
+            };
+            const result = OIDCPayloadSchema(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: { clientId: 'oidc_client_123' },
+            };
+            const result = OIDCPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+    });
+    describe('InsertOIDCPayloadSchema', () => {
+        test('should accept metadata payload', () => {
+            const payload = {
+                metadata: { setup: 'initial' },
+            };
+            const result = InsertOIDCPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+        test('should accept undefined', () => {
+            const result = InsertOIDCPayloadSchema(undefined);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toBeUndefined();
+        });
+        test('should accept empty metadata', () => {
+            const payload = {
+                metadata: {},
+            };
+            const result = InsertOIDCPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+    });
+    describe('UpdateOIDCPayloadSchema', () => {
+        test('should accept metadata update', () => {
+            const payload = {
+                metadata: { version: '2.0' },
+            };
+            const result = UpdateOIDCPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+    });
+});

package/dist/esm/app/registration/resources.d.ts

@@ -0,0 +1,12 @@
+import type { MondoIdentity } from '../../common/resources/init.js';
+import { type Registration, type UpsertRegistrationInput } from './schema.js';
+export declare class RegistrationResources {
+    private readonly instance;
+    constructor(instance: MondoIdentity);
+    static buildPath(id: string): string;
+    getItem(id: string): Promise<Registration>;
+    upsertItem(id: string, item: UpsertRegistrationInput): Promise<Registration>;
+}
+export declare function getRegistration(instance: MondoIdentity, id: string): Promise<Registration>;
+export declare function upsertRegistration(instance: MondoIdentity, id: string, item: UpsertRegistrationInput): Promise<Registration>;
+//# sourceMappingURL=resources.d.ts.map

package/dist/esm/app/registration/resources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../../../src/app/registration/resources.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAOpE,OAAO,EACL,KAAK,YAAY,EAEjB,KAAK,uBAAuB,EAE7B,MAAM,aAAa,CAAC;AAIrB,qBAAa,qBAAqB;IACb,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,aAAa;IAE3D,MAAM,CAAC,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAQ7B,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAI1C,UAAU,CACf,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,uBAAuB,GAC5B,OAAO,CAAC,YAAY,CAAC;CAGzB;AAED,wBAAsB,eAAe,CACnC,QAAQ,EAAE,aAAa,EACvB,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,YAAY,CAAC,CASvB;AAED,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,aAAa,EACvB,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,uBAAuB,GAC5B,OAAO,CAAC,YAAY,CAAC,CAYvB"}

package/dist/esm/app/registration/resources.js

@@ -0,0 +1,29 @@
+import { getItemWithAuthorization, insertItemWithAuthorization, } from '../../common/resources/operations.js';
+import { parseEgressSchema } from '../../common/resources/utils.js';
+import { PATH } from '../resources.js';
+import { RegistrationSchema, UpsertRegistrationPayloadSchema, } from './schema.js';
+const RESOURCE = 'registration';
+export class RegistrationResources {
+    instance;
+    constructor(instance) {
+        this.instance = instance;
+    }
+    static buildPath(id) {
+        if (id?.startsWith(PATH)) {
+            return id;
+        }
+        return [PATH, id, RESOURCE].filter(Boolean).join('/');
+    }
+    getItem(id) {
+        return getRegistration(this.instance, id);
+    }
+    upsertItem(id, item) {
+        return upsertRegistration(this.instance, id, item);
+    }
+}
+export async function getRegistration(instance, id) {
+    return parseEgressSchema(RegistrationSchema(await getItemWithAuthorization(new URL(RegistrationResources.buildPath(id), instance.config.host), instance.authorizer)));
+}
+export async function upsertRegistration(instance, id, item) {
+    return parseEgressSchema(RegistrationSchema(await insertItemWithAuthorization(new URL(RegistrationResources.buildPath(id), instance.config.host), instance.authorizer, parseEgressSchema(UpsertRegistrationPayloadSchema.onUndeclaredKey('delete')(item)))));
+}

package/dist/esm/app/registration/resources.test.d.ts

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

package/dist/esm/app/registration/resources.test.d.ts.map

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