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

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

@@ -2,7 +2,7 @@ export declare const SAMLSchema: import("arktype/internal/methods/object.ts").Ob
     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> | Map<string, any>>;
+    metadata: (In: import("arktype/internal/attributes.ts").Default<unknown, Map<string, string | number | boolean>>) => import("arktype").Out<Map<string, string | number | boolean>>;
 }, {}>;
 export type SAMLProperties = typeof SAMLSchema.inferIn;
 export type SAML = typeof SAMLSchema.inferOut;
@@ -22,7 +22,7 @@ export declare const InsertSAMLPayloadSchema: import("arktype").BaseType<{
         [x: string]: string | number | boolean;
     } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
         [x: string]: string | number | boolean;
-    } | undefined>) | undefined;
+    } | null>) | undefined;
 } | undefined, {}>;
 export type InsertSAMLInput = typeof InsertSAMLPayloadSchema.inferIn;
 export type InsertSAMLPayload = typeof InsertSAMLPayloadSchema.inferOut;
@@ -31,7 +31,7 @@ export declare const UpdateSAMLPayloadSchema: import("arktype/internal/methods/o
         [x: string]: string | number | boolean;
     } | Map<string, string | number | boolean> | null | undefined) => import("arktype").Out<{
         [x: string]: string | number | boolean;
-    } | undefined>) | undefined;
+    } | null>) | undefined;
 }, {}>;
 export type UpdateSAMLInput = typeof InsertSAMLPayloadSchema.inferIn;
 export type UpdateSAMLPayload = typeof InsertSAMLPayloadSchema.inferOut;

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

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/app/saml/schema.ts"],"names":[],"mappings":"AAUA,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;;;;;;kBACW,CAAC;AAChD,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"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/app/saml/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;;;;;;MAAsC,CAAC;AAC3E,MAAM,MAAM,eAAe,GAAG,OAAO,uBAAuB,CAAC,OAAO,CAAC;AACrE,MAAM,MAAM,iBAAiB,GAAG,OAAO,uBAAuB,CAAC,QAAQ,CAAC"}

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

@@ -1,6 +1,6 @@
 import { type } from 'arktype';
 import { OptionalDatePayloadSchema, OptionalDateSchema, } from '../../common/schema/dates.js';
-import { MetadataMapPropertySchema, MetadataPayloadPropertySchema, } from '../../common/schema/metadata.js';
+import { MetadataMapPropertySchema, MetadataPayloadPropertySchema, UpsertMetadataPropertyPayloadSchema, } from '../../common/schema/metadata.js';
 export const SAMLSchema = type({
     'updatedAt?': OptionalDateSchema,
     'deletedAt?': OptionalDateSchema,
@@ -11,5 +11,5 @@ export const SAMLPayloadSchema = type({
     'deletedAt?': OptionalDatePayloadSchema,
     'deactivatedAt?': OptionalDatePayloadSchema,
 }).and(MetadataPayloadPropertySchema);
-export const InsertSAMLPayloadSchema = MetadataPayloadPropertySchema.or('undefined');
-export const UpdateSAMLPayloadSchema = MetadataPayloadPropertySchema;
+export const InsertSAMLPayloadSchema = UpsertMetadataPropertyPayloadSchema.or('undefined');
+export const UpdateSAMLPayloadSchema = UpsertMetadataPropertyPayloadSchema;

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

@@ -18,7 +18,7 @@ export declare const AppSchema: import("arktype/internal/methods/object.ts").Obj
     updatedAt: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>);
     deletedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
     deactivatedAt?: Date | ((In: string) => import("arktype/internal/attributes.ts").To<Date>) | undefined;
-    metadata: (In: import("arktype/internal/attributes.ts").Default<unknown, Map<string, string | number | boolean>>) => import("arktype").Out<Map<string, string | number | boolean> | Map<string, any>>;
+    metadata: (In: import("arktype/internal/attributes.ts").Default<unknown, Map<string, string | number | boolean>>) => import("arktype").Out<Map<string, string | number | boolean>>;
 }, {}>;
 export type AppProperties = typeof AppSchema.inferIn;
 export type App = typeof AppSchema.inferOut;
@@ -63,6 +63,10 @@ export declare const UpdateAppPayloadSchema: import("arktype/internal/methods/ob
 }, {}>;
 export type UpdateAppInput = typeof UpdateAppPayloadSchema.inferIn;
 export type UpdateAppPayload = typeof UpdateAppPayloadSchema.inferOut;
+/**
+ * Association
+ */
+export declare const AppIdAssociationsSchema: import("arktype").BaseType<string[] | undefined, {}>;
 export declare const AppAssociationReferenceSchema: import("arktype/internal/methods/object.ts").ObjectType<{
     id: string;
     status: import("arktype/internal/attributes.ts").Default<"enabled" | "disabled", "disabled">;

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

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/app/schema.ts"],"names":[],"mappings":"AAaA,eAAO,MAAM,SAAS;;;CAGZ,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC;AAEtE,eAAO,MAAM,WAAW,qEAAc,CAAC;AACvC,MAAM,MAAM,KAAK,GAAG,OAAO,WAAW,CAAC,QAAQ,CAAC;AAEhD,eAAO,MAAM,mBAAmB;;MAE9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,mBAAmB,CAAC,QAAQ,CAAC;AAUhE,eAAO,MAAM,SAAS;;;;;;;;;;MAKW,CAAC;AAClC,MAAM,MAAM,aAAa,GAAG,OAAO,SAAS,CAAC,OAAO,CAAC;AACrD,MAAM,MAAM,GAAG,GAAG,OAAO,SAAS,CAAC,QAAQ,CAAC;AAE5C,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;MAOQ,CAAC;AACtC,MAAM,MAAM,UAAU,GAAG,OAAO,gBAAgB,CAAC,QAAQ,CAAC;AAE1D,eAAO,MAAM,sBAAsB;;;;;;;;;;MAKE,CAAC;AACtC,MAAM,MAAM,cAAc,GAAG,OAAO,sBAAsB,CAAC,OAAO,CAAC;AACnE,MAAM,MAAM,gBAAgB,GAAG,OAAO,sBAAsB,CAAC,QAAQ,CAAC;AAEtE,eAAO,MAAM,sBAAsB;;;;;;;;;MAIE,CAAC;AACtC,MAAM,MAAM,cAAc,GAAG,OAAO,sBAAsB,CAAC,OAAO,CAAC;AACnE,MAAM,MAAM,gBAAgB,GAAG,OAAO,sBAAsB,CAAC,QAAQ,CAAC;AAEtE,eAAO,MAAM,6BAA6B;;;;;MAMzC,CAAC;AACF,MAAM,MAAM,uBAAuB,GACjC,OAAO,6BAA6B,CAAC,QAAQ,CAAC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/app/schema.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,SAAS;;;CAGZ,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,OAAO,SAAS,CAAC,CAAC;AAEtE,eAAO,MAAM,WAAW,qEAAmC,CAAC;AAC5D,MAAM,MAAM,KAAK,GAAG,OAAO,WAAW,CAAC,QAAQ,CAAC;AAEhD,eAAO,MAAM,mBAAmB;;MAE9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,mBAAmB,CAAC,QAAQ,CAAC;AAUhE,eAAO,MAAM,SAAS;;;;;;;;;;MAKW,CAAC;AAClC,MAAM,MAAM,aAAa,GAAG,OAAO,SAAS,CAAC,OAAO,CAAC;AACrD,MAAM,MAAM,GAAG,GAAG,OAAO,SAAS,CAAC,QAAQ,CAAC;AAE5C,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;MAOQ,CAAC;AACtC,MAAM,MAAM,UAAU,GAAG,OAAO,gBAAgB,CAAC,QAAQ,CAAC;AAE1D,eAAO,MAAM,sBAAsB;;;;;;;;;;MAKE,CAAC;AACtC,MAAM,MAAM,cAAc,GAAG,OAAO,sBAAsB,CAAC,OAAO,CAAC;AACnE,MAAM,MAAM,gBAAgB,GAAG,OAAO,sBAAsB,CAAC,QAAQ,CAAC;AAEtE,eAAO,MAAM,sBAAsB;;;;;;;;;MAIE,CAAC;AACtC,MAAM,MAAM,cAAc,GAAG,OAAO,sBAAsB,CAAC,OAAO,CAAC;AACnE,MAAM,MAAM,gBAAgB,GAAG,OAAO,sBAAsB,CAAC,QAAQ,CAAC;AAEtE;;GAEG;AACH,eAAO,MAAM,uBAAuB,sDAEnC,CAAC;AAEF,eAAO,MAAM,6BAA6B;;;;;MAMzC,CAAC;AACF,MAAM,MAAM,uBAAuB,GACjC,OAAO,6BAA6B,CAAC,QAAQ,CAAC"}

package/dist/esm/app/schema.js

@@ -1,12 +1,13 @@
 import { type } from 'arktype';
 import { OptionalDatePayloadSchema, OptionalDateSchema, RequiredDatePayloadSchema, RequiredDateSchema, } from '../common/index.js';
+import { KSUIDSchema } from '../common/schema/id.js';
 import { MetadataMapPropertySchema, MetadataPayloadPropertySchema, } from '../common/schema/metadata.js';
-import { generateAppId } from './utils.js';
+import { Model, generateAppId } from './utils.js';
 export const AppStatus = {
     ENABLED: 'enabled',
     DISABLED: 'disabled',
 };
-export const AppIdSchema = type.string;
+export const AppIdSchema = KSUIDSchema(Model.App.UIDPrefix);
 export const AppIdPropertySchema = type({
     id: AppIdSchema,
 });
@@ -41,6 +42,10 @@ export const UpdateAppPayloadSchema = type({
     label: type('string').or(type.null).optional(),
     description: type('string').or(type.null).optional(),
 }).and(MetadataPayloadPropertySchema);
+/**
+ * Association
+ */
+export const AppIdAssociationsSchema = type('undefined').or(AppIdSchema.array());
 export const AppAssociationReferenceSchema = AppIdPropertySchema.and(type({
     status: StatusSchema.default('disabled'),
     label: type('string'),

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":""}

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

@@ -0,0 +1,182 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { AppAssociationReferenceSchema, AppIdPropertySchema, AppIdSchema, AppSchema, AppStatus, UpdateAppPayloadSchema, } from './schema.js';
+import { generateAppId } from './utils.js';
+describe('App - Schema', () => {
+    describe('AppStatus constants', () => {
+        test('should have correct status values', () => {
+            expect(AppStatus.ENABLED).toBe('enabled');
+            expect(AppStatus.DISABLED).toBe('disabled');
+        });
+    });
+    describe('AppIdSchema', () => {
+        test('should accept valid app ID', () => {
+            const id = generateAppId();
+            const result = AppIdSchema(id);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toBe(id);
+        });
+        test('should reject invalid app ID format', () => {
+            expect(AppIdSchema('invalid_id')).toBeInstanceOf(type.errors);
+            expect(AppIdSchema('wrong_prefix_123')).toBeInstanceOf(type.errors);
+        });
+        test('should reject non-string values', () => {
+            expect(AppIdSchema(123)).toBeInstanceOf(type.errors);
+            expect(AppIdSchema(null)).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('AppIdPropertySchema', () => {
+        test('should accept valid id property', () => {
+            const payload = { id: generateAppId() };
+            const result = AppIdPropertySchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+        test('should reject missing id', () => {
+            const result = AppIdPropertySchema({});
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject invalid id format', () => {
+            const result = AppIdPropertySchema({ id: 'invalid_id' });
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('AppSchema', () => {
+        test('should accept complete app object', () => {
+            const app = {
+                id: generateAppId(),
+                status: 'enabled',
+                label: 'My Application',
+                description: 'Application description',
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: { key: 'value' },
+            };
+            const result = AppSchema(app);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept minimal app object', () => {
+            const app = {
+                id: generateAppId(),
+                status: 'enabled',
+                label: 'Simple App',
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: {},
+            };
+            const result = AppSchema(app);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should accept app with optional dates', () => {
+            const app = {
+                id: generateAppId(),
+                status: 'disabled',
+                label: 'Disabled App',
+                description: 'This app is disabled',
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                deletedAt: new Date(),
+                deactivatedAt: new Date(),
+                metadata: {},
+            };
+            const result = AppSchema(app);
+            expect(result).not.toBeInstanceOf(type.errors);
+        });
+        test('should reject invalid status', () => {
+            const app = {
+                id: generateAppId(),
+                status: 'invalid-status',
+                label: 'My App',
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                metadata: {},
+            };
+            const result = AppSchema(app);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject missing required fields', () => {
+            const app = {
+                id: generateAppId(),
+                status: 'enabled',
+                // missing label, createdAt, updatedAt, metadata
+            };
+            const result = AppSchema(app);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('UpdateAppPayloadSchema', () => {
+        test('should accept all optional fields', () => {
+            const payload = {
+                status: 'disabled',
+                label: 'Updated App',
+                description: 'Updated description',
+                metadata: { updated: true },
+            };
+            const result = UpdateAppPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+        test('should accept empty update payload', () => {
+            const result = UpdateAppPayloadSchema({});
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual({});
+        });
+        test('should accept partial updates', () => {
+            const payload = { label: 'New Label' };
+            const result = UpdateAppPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+        test('should accept null values for nullable fields', () => {
+            const payload = {
+                label: null,
+                description: null,
+            };
+            const result = UpdateAppPayloadSchema(payload);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(payload);
+        });
+        test('should reject invalid status', () => {
+            const payload = { status: 'invalid-status' };
+            const result = UpdateAppPayloadSchema(payload);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+    describe('AppAssociationReferenceSchema', () => {
+        test('should accept complete association reference', () => {
+            const reference = {
+                id: generateAppId(),
+                status: 'enabled',
+                label: 'Associated App',
+                model: 'App',
+            };
+            const result = AppAssociationReferenceSchema(reference);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toEqual(reference);
+        });
+        test('should use default status when not provided', () => {
+            const reference = {
+                id: generateAppId(),
+                label: 'Test App',
+                model: 'App',
+            };
+            const result = AppAssociationReferenceSchema(reference);
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result.status).toBe('disabled'); // default value
+        });
+        test('should reject missing required fields', () => {
+            const reference = { id: generateAppId() };
+            const result = AppAssociationReferenceSchema(reference);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+        test('should reject invalid model value', () => {
+            const reference = {
+                id: generateAppId(),
+                label: 'Test App',
+                model: 'InvalidModel',
+            };
+            const result = AppAssociationReferenceSchema(reference);
+            expect(result).toBeInstanceOf(type.errors);
+        });
+    });
+});

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

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

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

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

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

@@ -0,0 +1,40 @@
+import { describe, expect, test } from 'vitest';
+import { Model, generateAppId, generateOAuthId } from './utils.js';
+describe('App - Utils', () => {
+    describe('Model constants', () => {
+        test('should have correct UID prefixes', () => {
+            expect(Model.App.UIDPrefix).toBe('app');
+            expect(Model.OAuth.UIDPrefix).toBe('aoa');
+        });
+    });
+    describe('generateAppId', () => {
+        test('should generate ID with correct prefix', () => {
+            const id = generateAppId();
+            expect(id).toMatch(/^app_[A-Za-z0-9]+$/);
+        });
+        test('should generate unique IDs', () => {
+            const id1 = generateAppId();
+            const id2 = generateAppId();
+            expect(id1).not.toBe(id2);
+        });
+        test('should generate IDs with correct length', () => {
+            const id = generateAppId();
+            expect(id.length).toBeGreaterThan(4); // prefix + underscore + KSUID
+        });
+    });
+    describe('generateOAuthId', () => {
+        test('should generate ID with correct prefix', () => {
+            const id = generateOAuthId();
+            expect(id).toMatch(/^aoa_[A-Za-z0-9]+$/);
+        });
+        test('should generate unique IDs', () => {
+            const id1 = generateOAuthId();
+            const id2 = generateOAuthId();
+            expect(id1).not.toBe(id2);
+        });
+        test('should generate IDs with correct length', () => {
+            const id = generateOAuthId();
+            expect(id.length).toBeGreaterThan(4); // prefix + underscore + KSUID
+        });
+    });
+});