@go-mondo/identity-sdk 0.0.2-beta.1 → 0.0.2-beta.13

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

@@ -0,0 +1,253 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { AppResources } from './resources.js';
+describe('App Resources', () => {
+    let mockInstance;
+    let appResources;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // Mock MondoIdentity instance
+        mockInstance = {
+            config: {
+                host: 'https://api.example.com',
+                accessToken: 'test-token',
+            },
+            authorizer: vi.fn((req) => req),
+        };
+        appResources = new AppResources(mockInstance);
+    });
+    describe('AppResources class', () => {
+        test('should initialize with MondoIdentity instance', () => {
+            expect(appResources).toBeInstanceOf(AppResources);
+            // biome-ignore lint/complexity/useLiteralKeys: <explanation>
+            expect(appResources['instance']).toBe(mockInstance);
+        });
+        describe('buildPath static method', () => {
+            test('should build path without ID', () => {
+                const path = AppResources.buildPath();
+                expect(path).toBe('/v1/apps');
+            });
+            test('should build path with app ID', () => {
+                const path = AppResources.buildPath('app_123');
+                expect(path).toBe('/v1/apps/app_123');
+            });
+            test('should return existing path if ID already starts with /v1/apps', () => {
+                const existingPath = '/v1/apps/app_456/custom/path';
+                const path = AppResources.buildPath(existingPath);
+                expect(path).toBe(existingPath);
+            });
+            test('should handle empty ID', () => {
+                const path = AppResources.buildPath('');
+                expect(path).toBe('/v1/apps');
+            });
+            test('should handle undefined ID', () => {
+                const path = AppResources.buildPath(undefined);
+                expect(path).toBe('/v1/apps');
+            });
+            test('should filter out falsy values correctly', () => {
+                const path = AppResources.buildPath('app_789');
+                expect(path).toBe('/v1/apps/app_789');
+            });
+            test('should handle various app ID patterns', () => {
+                const testCases = [
+                    { input: 'app_12345', expected: '/v1/apps/app_12345' },
+                    { input: 'app_production', expected: '/v1/apps/app_production' },
+                    { input: 'app_test_env', expected: '/v1/apps/app_test_env' },
+                    { input: '/v1/apps/existing', expected: '/v1/apps/existing' },
+                    { input: '/v1/apps/nested/path', expected: '/v1/apps/nested/path' },
+                ];
+                for (const { input, expected } of testCases) {
+                    expect(AppResources.buildPath(input)).toBe(expected);
+                }
+            });
+        });
+        describe('method signatures', () => {
+            test('should have listItems method', () => {
+                expect(typeof appResources.listItems).toBe('function');
+                expect(appResources.listItems.length).toBe(1); // optional pagination parameter
+            });
+            test('should have getItem method', () => {
+                expect(typeof appResources.getItem).toBe('function');
+                expect(appResources.getItem.length).toBe(1); // id parameter
+            });
+            test('should have insertItem method', () => {
+                expect(typeof appResources.insertItem).toBe('function');
+                expect(appResources.insertItem.length).toBe(1); // item parameter
+            });
+            test('should have updateItem method', () => {
+                expect(typeof appResources.updateItem).toBe('function');
+                expect(appResources.updateItem.length).toBe(2); // id and item parameters
+            });
+            test('should have deleteItem method', () => {
+                expect(typeof appResources.deleteItem).toBe('function');
+                expect(appResources.deleteItem.length).toBe(1); // id parameter
+            });
+        });
+    });
+    describe('PATH constant', () => {
+        test('should export correct PATH constant', async () => {
+            const { PATH } = await import('./resources.js');
+            expect(PATH).toBe('/v1/apps');
+        });
+    });
+    describe('URL building scenarios', () => {
+        test('should create proper URL structure for different app types', () => {
+            const scenarios = [
+                { appId: 'app_web_frontend', expected: '/v1/apps/app_web_frontend' },
+                { appId: 'app_mobile_ios', expected: '/v1/apps/app_mobile_ios' },
+                { appId: 'app_api_gateway', expected: '/v1/apps/app_api_gateway' },
+                {
+                    appId: 'app_background_worker',
+                    expected: '/v1/apps/app_background_worker',
+                },
+            ];
+            for (const { appId, expected } of scenarios) {
+                const result = AppResources.buildPath(appId);
+                expect(result).toBe(expected);
+                expect(result).toMatch(/^\/v1\/apps\//);
+            }
+        });
+        test('should handle edge cases in path building', () => {
+            // Test with already formatted paths
+            expect(AppResources.buildPath('/v1/apps/already/formatted')).toBe('/v1/apps/already/formatted');
+            // Test with empty string
+            expect(AppResources.buildPath('')).toBe('/v1/apps');
+            // Test with undefined
+            expect(AppResources.buildPath(undefined)).toBe('/v1/apps');
+            // Test with null
+            expect(AppResources.buildPath(null)).toBe('/v1/apps');
+            // Test with single character
+            expect(AppResources.buildPath('a')).toBe('/v1/apps/a');
+        });
+        test('should create valid URL paths for various app environments', () => {
+            const environments = [
+                'app_development',
+                'app_staging',
+                'app_production',
+                'app_testing',
+                'app_sandbox',
+            ];
+            for (const env of environments) {
+                const path = AppResources.buildPath(env);
+                expect(path).toBe(`/v1/apps/${env}`);
+                expect(path).toMatch(/^\/v1\/apps\/app_[a-z]+$/);
+            }
+        });
+    });
+    describe('Integration with MondoIdentity instance', () => {
+        test('should store MondoIdentity instance internally', () => {
+            // biome-ignore lint/complexity/useLiteralKeys: <explanation>
+            const internalInstance = appResources['instance'];
+            expect(internalInstance).toBe(mockInstance);
+            expect(internalInstance.config.host).toBe('https://api.example.com');
+            expect(internalInstance.config.accessToken).toBe('test-token');
+        });
+        test('should maintain reference to authorizer function', () => {
+            // biome-ignore lint/complexity/useLiteralKeys: <explanation>
+            const internalInstance = appResources['instance'];
+            expect(typeof internalInstance.authorizer).toBe('function');
+            expect(internalInstance.authorizer).toBe(mockInstance.authorizer);
+        });
+        test('should work with different MondoIdentity configurations', () => {
+            const customInstance = {
+                config: {
+                    host: 'https://custom-apps.api.com',
+                    accessToken: 'custom-app-token',
+                },
+                authorizer: vi.fn(),
+            };
+            const customResources = new AppResources(customInstance);
+            // biome-ignore lint/complexity/useLiteralKeys: <explanation>
+            expect(customResources['instance']).toBe(customInstance);
+            // biome-ignore lint/complexity/useLiteralKeys: <explanation>
+            expect(customResources['instance'].config.host).toBe('https://custom-apps.api.com');
+        });
+    });
+    describe('Class structure and inheritance', () => {
+        test('should have proper class structure', () => {
+            expect(AppResources).toBeDefined();
+            expect(typeof AppResources).toBe('function');
+            expect(AppResources.prototype.constructor).toBe(AppResources);
+        });
+        test('should have static buildPath method', () => {
+            expect(typeof AppResources.buildPath).toBe('function');
+            expect(AppResources.buildPath).toBeDefined();
+        });
+        test('should have all CRUD instance methods', () => {
+            const methods = [
+                'listItems',
+                'getItem',
+                'insertItem',
+                'updateItem',
+                'deleteItem',
+            ];
+            for (const methodName of methods) {
+                expect(typeof appResources[methodName]).toBe('function');
+                expect(appResources[methodName]).toBeDefined();
+            }
+        });
+        test('should maintain method binding', () => {
+            const { listItems, getItem, insertItem, updateItem, deleteItem } = appResources;
+            expect(typeof listItems).toBe('function');
+            expect(typeof getItem).toBe('function');
+            expect(typeof insertItem).toBe('function');
+            expect(typeof updateItem).toBe('function');
+            expect(typeof deleteItem).toBe('function');
+        });
+    });
+    describe('CRUD operation method signatures', () => {
+        test('should have correct parameter counts for each method', () => {
+            // listItems(pagination?: Pagination)
+            expect(appResources.listItems.length).toBe(1);
+            // getItem(id: string)
+            expect(appResources.getItem.length).toBe(1);
+            // insertItem(item: InsertAppInput)
+            expect(appResources.insertItem.length).toBe(1);
+            // updateItem(id: string, item: UpdateAppInput)
+            expect(appResources.updateItem.length).toBe(2);
+            // deleteItem(id: string)
+            expect(appResources.deleteItem.length).toBe(1);
+        });
+        test('should support full CRUD workflow pattern', () => {
+            // This test verifies the class provides a complete CRUD interface
+            // without actually calling the methods (which would require complex mocking)
+            const crudMethods = {
+                create: 'insertItem',
+                read: ['listItems', 'getItem'],
+                update: 'updateItem',
+                delete: 'deleteItem',
+            };
+            // Create operation
+            expect(appResources).toHaveProperty(crudMethods.create);
+            // Read operations
+            for (const method of crudMethods.read) {
+                expect(appResources).toHaveProperty(method);
+            }
+            // Update operation
+            expect(appResources).toHaveProperty(crudMethods.update);
+            // Delete operation
+            expect(appResources).toHaveProperty(crudMethods.delete);
+        });
+    });
+    describe('Path filtering and validation', () => {
+        test('should properly filter out falsy values in path construction', () => {
+            const falsyValues = [null, undefined, ''];
+            for (const value of falsyValues) {
+                const path = AppResources.buildPath(value);
+                expect(path).toBe('/v1/apps');
+            }
+        });
+        test('should handle complex app ID formats', () => {
+            const complexIds = [
+                'app_complex-name_123',
+                'app_with.dots',
+                'app_with_multiple_underscores',
+                'app-with-dashes',
+                'app123numbers',
+            ];
+            for (const id of complexIds) {
+                const path = AppResources.buildPath(id);
+                expect(path).toBe(`/v1/apps/${id}`);
+            }
+        });
+    });
+});

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

@@ -0,0 +1,16 @@
+import type { MondoIdentity } from '../../common/resources/init.js';
+import { type InsertSAMLInput, type SAML, type UpdateSAMLInput } from './schema.js';
+export declare class SAMLResources {
+    private readonly instance;
+    constructor(instance: MondoIdentity);
+    static buildPath(appId: string): string;
+    getItem(appId: string): Promise<SAML>;
+    insertItem(appId: string, item?: InsertSAMLInput): Promise<SAML>;
+    updateItem(appId: string, item: UpdateSAMLInput): Promise<SAML>;
+    deleteItem(appId: string): Promise<SAML>;
+}
+export declare function getSAML(instance: MondoIdentity, appId: string): Promise<SAML>;
+export declare function insertSAML(instance: MondoIdentity, appId: string, item?: InsertSAMLInput): Promise<SAML>;
+export declare function updateSAML(instance: MondoIdentity, appId: string, item: UpdateSAMLInput): Promise<SAML>;
+export declare function deleteSAML(instance: MondoIdentity, appId: string): Promise<SAML>;
+//# sourceMappingURL=resources.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../../../../src/app/saml/resources.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAQpE,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,CAOf;AAED,wBAAsB,UAAU,CAC9B,QAAQ,EAAE,aAAa,EACvB,KAAK,EAAE,MAAM,EACb,IAAI,CAAC,EAAE,eAAe,GACrB,OAAO,CAAC,IAAI,CAAC,CAQf;AAED,wBAAsB,UAAU,CAC9B,QAAQ,EAAE,aAAa,EACvB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,eAAe,GACpB,OAAO,CAAC,IAAI,CAAC,CAQf;AAED,wBAAsB,UAAU,CAC9B,QAAQ,EAAE,aAAa,EACvB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,CAAC,CAOf"}

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

@@ -0,0 +1,40 @@
+import { deleteItemWithAuthorization, getItemWithAuthorization, insertItemWithAuthorization, updateItemWithAuthorization, } from '../../common/resources/operations.js';
+import { PATH } from '../resources.js';
+import { InsertSAMLPayloadSchema, SAMLSchema, UpdateSAMLPayloadSchema, } from './schema.js';
+const RESOURCE = 'saml';
+export class SAMLResources {
+    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 getSAML(this.instance, appId);
+    }
+    insertItem(appId, item) {
+        return insertSAML(this.instance, appId, item);
+    }
+    updateItem(appId, item) {
+        return updateSAML(this.instance, appId, item);
+    }
+    deleteItem(appId) {
+        return deleteSAML(this.instance, appId);
+    }
+}
+export async function getSAML(instance, appId) {
+    return SAMLSchema.parse(await getItemWithAuthorization(new URL(SAMLResources.buildPath(appId), instance.config.host), instance.authorizer));
+}
+export async function insertSAML(instance, appId, item) {
+    return SAMLSchema.parse(await insertItemWithAuthorization(new URL(SAMLResources.buildPath(appId), instance.config.host), instance.authorizer, InsertSAMLPayloadSchema.parse(item)));
+}
+export async function updateSAML(instance, appId, item) {
+    return SAMLSchema.parse(await updateItemWithAuthorization(new URL(SAMLResources.buildPath(appId), instance.config.host), instance.authorizer, UpdateSAMLPayloadSchema.parse(item)));
+}
+export async function deleteSAML(instance, appId) {
+    return SAMLSchema.parse(await deleteItemWithAuthorization(new URL(SAMLResources.buildPath(appId), instance.config.host), instance.authorizer));
+}

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

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+export declare const SAMLSchema: z.ZodObject<{
+    metadata: z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodCustom<Map<string, string | number | boolean>, Map<string, string | number | boolean>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>, z.ZodTransform<Map<string, string | number | boolean>, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>;
+    updatedAt: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>>;
+    deletedAt: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>>;
+    deactivatedAt: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>>;
+}, z.core.$strip>;
+export type SAMLProperties = z.input<typeof SAMLSchema>;
+export type SAML = z.output<typeof SAMLSchema>;
+export declare const SAMLPayloadSchema: z.ZodObject<{
+    metadata: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodCustom<Map<string, string | number | boolean>, Map<string, string | number | boolean>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>, z.ZodTransform<Record<string, string | number | boolean> | undefined, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>>;
+    updatedAt: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>, z.ZodTransform<string | undefined, Date | undefined>>>;
+    deletedAt: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>, z.ZodTransform<string | undefined, Date | undefined>>>;
+    deactivatedAt: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>, z.ZodTransform<string | undefined, Date | undefined>>>;
+}, z.core.$strip>;
+export type SAMLPayload = z.output<typeof SAMLPayloadSchema>;
+export declare const InsertSAMLPayloadSchema: z.ZodUnion<readonly [z.ZodObject<{
+    metadata: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodCustom<Map<string, string | number | boolean>, Map<string, string | number | boolean>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>, z.ZodTransform<Record<string, string | number | boolean> | null | undefined, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>>;
+}, z.core.$strip>, z.ZodUndefined]>;
+export type InsertSAMLInput = z.input<typeof InsertSAMLPayloadSchema>;
+export type InsertSAMLPayload = z.output<typeof InsertSAMLPayloadSchema>;
+export declare const UpdateSAMLPayloadSchema: z.ZodObject<{
+    metadata: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodCustom<Map<string, string | number | boolean>, Map<string, string | number | boolean>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>, z.ZodTransform<Record<string, string | number | boolean> | null | undefined, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>>;
+}, z.core.$strip>;
+export type UpdateSAMLInput = z.input<typeof InsertSAMLPayloadSchema>;
+export type UpdateSAMLPayload = z.output<typeof InsertSAMLPayloadSchema>;
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/app/saml/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB,eAAO,MAAM,UAAU;;;;;iBAKrB,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AACxD,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,UAAU,CAAC,CAAC;AAE/C,eAAO,MAAM,iBAAiB;;;;;iBAK5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE7D,eAAO,MAAM,uBAAuB;;mCAGlC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACtE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAEzE,eAAO,MAAM,uBAAuB;;iBAAsC,CAAC;AAC3E,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACtE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC"}

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

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { OptionalDatePayloadSchema, OptionalDateSchema, } from '../../common/schema/dates.js';
+import { MetadataMapPropertySchema, MetadataPayloadPropertySchema, UpsertMetadataPropertyPayloadSchema, } from '../../common/schema/metadata.js';
+export const SAMLSchema = z.object({
+    updatedAt: OptionalDateSchema.optional(),
+    deletedAt: OptionalDateSchema.optional(),
+    deactivatedAt: OptionalDateSchema.optional(),
+    ...MetadataMapPropertySchema.shape,
+});
+export const SAMLPayloadSchema = z.object({
+    updatedAt: OptionalDatePayloadSchema.optional(),
+    deletedAt: OptionalDatePayloadSchema.optional(),
+    deactivatedAt: OptionalDatePayloadSchema.optional(),
+    ...MetadataPayloadPropertySchema.shape,
+});
+export const InsertSAMLPayloadSchema = z.union([
+    UpsertMetadataPropertyPayloadSchema,
+    z.undefined(),
+]);
+export const UpdateSAMLPayloadSchema = UpsertMetadataPropertyPayloadSchema;

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

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+export declare const AppStatus: {
+    readonly ENABLED: "enabled";
+    readonly DISABLED: "disabled";
+};
+export type AnyAppStatus = (typeof AppStatus)[keyof typeof AppStatus];
+export declare const AppIdSchema: z.ZodString;
+export type AppId = z.output<typeof AppIdSchema>;
+export declare const AppIdPropertySchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export type AppIdProperty = z.output<typeof AppIdPropertySchema>;
+export declare const AppSchema: z.ZodObject<{
+    metadata: z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodCustom<Map<string, string | number | boolean>, Map<string, string | number | boolean>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>, z.ZodTransform<Map<string, string | number | boolean>, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>;
+    createdAt: z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>;
+    updatedAt: z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>;
+    deletedAt: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>>;
+    deactivatedAt: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>>;
+    status: z.ZodEnum<{
+        enabled: "enabled";
+        disabled: "disabled";
+    }>;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUndefined]>>;
+    id: z.ZodString;
+}, z.core.$strip>;
+export type AppProperties = z.input<typeof AppSchema>;
+export type App = z.output<typeof AppSchema>;
+export declare const AppPayloadSchema: z.ZodObject<{
+    metadata: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodCustom<Map<string, string | number | boolean>, Map<string, string | number | boolean>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>, z.ZodTransform<Record<string, string | number | boolean> | undefined, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>>;
+    createdAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+    updatedAt: z.ZodPipe<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>, z.ZodTransform<string, Date>>;
+    deletedAt: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>, z.ZodTransform<string | undefined, Date | undefined>>>;
+    deactivatedAt: z.ZodOptional<z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodDate, z.ZodPipe<z.ZodString, z.ZodTransform<Date, string>>]>>, z.ZodTransform<string | undefined, Date | undefined>>>;
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        enabled: "enabled";
+        disabled: "disabled";
+    }>;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUndefined]>>;
+}, z.core.$strip>;
+export type AppPayload = z.output<typeof AppPayloadSchema>;
+export declare const InsertAppPayloadSchema: z.ZodObject<{
+    metadata: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodCustom<Map<string, string | number | boolean>, Map<string, string | number | boolean>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>, z.ZodTransform<Record<string, string | number | boolean> | undefined, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>>;
+    id: z.ZodDefault<z.ZodString>;
+    status: z.ZodDefault<z.ZodEnum<{
+        enabled: "enabled";
+        disabled: "disabled";
+    }>>;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type InsertAppInput = z.input<typeof InsertAppPayloadSchema>;
+export type InsertAppPayload = z.output<typeof InsertAppPayloadSchema>;
+export declare const UpdateAppPayloadSchema: z.ZodObject<{
+    metadata: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodUndefined, z.ZodNull, z.ZodCustom<Map<string, string | number | boolean>, Map<string, string | number | boolean>>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>, z.ZodTransform<Record<string, string | number | boolean> | undefined, Record<string, string | number | boolean> | Map<string, string | number | boolean> | null | undefined>>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        enabled: "enabled";
+        disabled: "disabled";
+    }>>;
+    label: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+    description: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNull]>>;
+}, z.core.$strip>;
+export type UpdateAppInput = z.input<typeof UpdateAppPayloadSchema>;
+export type UpdateAppPayload = z.output<typeof UpdateAppPayloadSchema>;
+/**
+ * Association
+ */
+export declare const AppIdAssociationsSchema: z.ZodUnion<[z.ZodUndefined, z.ZodArray<z.ZodString>]>;
+export declare const AppAssociationReferenceSchema: z.ZodObject<{
+    status: z.ZodDefault<z.ZodEnum<{
+        enabled: "enabled";
+        disabled: "disabled";
+    }>>;
+    label: z.ZodString;
+    model: z.ZodLiteral<"App">;
+    id: z.ZodString;
+}, z.core.$strip>;
+export type AppAssociationReference = z.output<typeof AppAssociationReferenceSchema>;
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/app/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAcxB,eAAO,MAAM,SAAS;;;CAGZ,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC;AAEtE,eAAO,MAAM,WAAW,aAAmC,CAAC;AAC5D,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,WAAW,CAAC,CAAC;AAEjD,eAAO,MAAM,mBAAmB;;iBAE9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAWjE,eAAO,MAAM,SAAS;;;;;;;;;;;;;iBAOpB,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC;AACtD,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,SAAS,CAAC,CAAC;AAE7C,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;iBAQ3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE3D,eAAO,MAAM,sBAAsB;;;;;;;;;iBAMjC,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACpE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEvE,eAAO,MAAM,sBAAsB;;;;;;;;iBAKjC,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACpE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEvE;;GAEG;AACH,eAAO,MAAM,uBAAuB,uDAAyC,CAAC;AAE9E,eAAO,MAAM,6BAA6B;;;;;;;;iBAKxC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAC5C,OAAO,6BAA6B,CACrC,CAAC"}

package/dist/esm/app/schema.js

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+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, generateAppId } from './utils.js';
+export const AppStatus = {
+    ENABLED: 'enabled',
+    DISABLED: 'disabled',
+};
+export const AppIdSchema = KSUIDSchema(Model.App.UIDPrefix);
+export const AppIdPropertySchema = z.object({
+    id: AppIdSchema,
+});
+const StatusSchema = z.enum([AppStatus.ENABLED, AppStatus.DISABLED]);
+const BaseSchema = z.object({
+    ...AppIdPropertySchema.shape,
+    status: StatusSchema,
+    label: z.string(),
+    description: z.string().or(z.undefined()).optional(),
+});
+export const AppSchema = z.object({
+    ...BaseSchema.shape,
+    createdAt: RequiredDateSchema,
+    updatedAt: RequiredDateSchema,
+    deletedAt: OptionalDateSchema.optional(),
+    deactivatedAt: OptionalDateSchema.optional(),
+    ...MetadataMapPropertySchema.shape,
+});
+export const AppPayloadSchema = z.object({
+    ...BaseSchema.shape,
+    ...AppIdPropertySchema.shape,
+    createdAt: RequiredDatePayloadSchema,
+    updatedAt: RequiredDatePayloadSchema,
+    deletedAt: OptionalDatePayloadSchema.optional(),
+    deactivatedAt: OptionalDatePayloadSchema.optional(),
+    ...MetadataPayloadPropertySchema.shape,
+});
+export const InsertAppPayloadSchema = z.object({
+    id: AppIdSchema.default(() => generateAppId()),
+    status: StatusSchema.default(AppStatus.ENABLED),
+    label: z.string(),
+    description: z.string().optional(),
+    ...MetadataPayloadPropertySchema.shape,
+});
+export const UpdateAppPayloadSchema = z.object({
+    status: StatusSchema.optional(),
+    label: z.string().or(z.null()).optional(),
+    description: z.string().or(z.null()).optional(),
+    ...MetadataPayloadPropertySchema.shape,
+});
+/**
+ * Association
+ */
+export const AppIdAssociationsSchema = z.undefined().or(z.array(AppIdSchema));
+export const AppAssociationReferenceSchema = z.object({
+    ...AppIdPropertySchema.shape,
+    status: StatusSchema.default('disabled'),
+    label: z.string(),
+    model: z.literal('App'),
+});

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

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

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

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