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

package/dist/esm/common/schema/url.test.js

@@ -0,0 +1,72 @@
+import { describe, expect, test } from 'vitest';
+import { appendSearchParams } from './url.js';
+describe('Common Schema - URL', () => {
+    describe('appendSearchParams', () => {
+        test('should append search params from Map to path', () => {
+            const params = new Map([
+                ['key1', 'value1'],
+                ['key2', 'value2'],
+            ]);
+            const result = appendSearchParams('/api/test', params);
+            expect(result).toBe('/api/test?key1=value1&key2=value2');
+        });
+        test('should append search params from URLSearchParams to path', () => {
+            const params = new URLSearchParams();
+            params.set('foo', 'bar');
+            params.set('baz', 'qux');
+            const result = appendSearchParams('/api/endpoint', params);
+            expect(result).toBe('/api/endpoint?foo=bar&baz=qux');
+        });
+        test('should handle empty params', () => {
+            const params = new Map();
+            const result = appendSearchParams('/api/test', params);
+            expect(result).toBe('/api/test');
+        });
+        test('should skip undefined values', () => {
+            const params = new Map([
+                ['key1', 'value1'],
+                ['key2', undefined],
+                ['key3', 'value3'],
+            ]);
+            const result = appendSearchParams('/api/test', params);
+            expect(result).toBe('/api/test?key1=value1&key3=value3');
+        });
+        test('should skip null values', () => {
+            const params = new Map([
+                ['key1', 'value1'],
+                ['key2', null],
+                ['key3', 'value3'],
+            ]);
+            const result = appendSearchParams('/api/test', params);
+            expect(result).toBe('/api/test?key1=value1&key3=value3');
+        });
+        test('should skip empty string values', () => {
+            const params = new Map([
+                ['key1', 'value1'],
+                ['key2', ''],
+                ['key3', 'value3'],
+            ]);
+            const result = appendSearchParams('/api/test', params);
+            expect(result).toBe('/api/test?key1=value1&key3=value3');
+        });
+        test('should handle path without leading slash', () => {
+            const params = new Map([['param', 'value']]);
+            const result = appendSearchParams('api/test', params);
+            expect(result).toBe('api/test?param=value');
+        });
+        test('should handle single parameter', () => {
+            const params = new Map([['single', 'value']]);
+            const result = appendSearchParams('/path', params);
+            expect(result).toBe('/path?single=value');
+        });
+        test('should handle all falsy values', () => {
+            const params = new Map([
+                ['key1', undefined],
+                ['key2', null],
+                ['key3', ''],
+            ]);
+            const result = appendSearchParams('/api/test', params);
+            expect(result).toBe('/api/test');
+        });
+    });
+});

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

@@ -1,5 +1,6 @@
-export * from './schema/schema.js';
+export * from './organization/schema.js';
 export * from './users/resources.js';
 export * from './users/schema.js';
 export * from './users/utils.js';
+export * from './schema.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/customer/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AAEnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/customer/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AAEzC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AAEjC,cAAc,aAAa,CAAC"}

package/dist/esm/customer/index.js

@@ -1,4 +1,5 @@
-export * from './schema/schema.js';
+export * from './organization/schema.js';
 export * from './users/resources.js';
 export * from './users/schema.js';
 export * from './users/utils.js';
+export * from './schema.js';

package/dist/esm/customer/{schema/organization.d.ts → organization/schema.d.ts}

@@ -3,8 +3,6 @@ export declare const OrganizationStatus: {
     readonly SUSPENDED: "suspended";
 };
 export type AnyOrganizationStatus = (typeof OrganizationStatus)[keyof typeof OrganizationStatus];
-export declare const OrganizationIdSchema: import("arktype/internal/methods/string.ts").StringType<string, {}>;
-export type OrganizationId = typeof OrganizationIdSchema.inferOut;
 export declare const OrganizationIdPropertySchema: import("arktype/internal/methods/object.ts").ObjectType<{
     id: string;
 }, {}>;
@@ -45,10 +43,13 @@ export declare const UpdateOrganizationPayloadSchema: import("arktype/internal/m
     } | null>) | undefined;
 }, {}>;
 export type UpdateOrganizationPayload = typeof UpdateOrganizationPayloadSchema.inferOut;
+/**
+ * Association
+ */
 export declare const OrganizationAssociationReferenceSchema: import("arktype/internal/methods/object.ts").ObjectType<{
     id: string;
     name: string;
     model: "Organization";
 }, {}>;
 export type OrganizationAssociationReference = typeof OrganizationAssociationReferenceSchema.inferOut;
-//# sourceMappingURL=organization.d.ts.map
+//# sourceMappingURL=schema.d.ts.map

package/dist/esm/customer/organization/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/customer/organization/schema.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,kBAAkB;;;CAGrB,CAAC;AACX,MAAM,MAAM,qBAAqB,GAC/B,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,OAAO,kBAAkB,CAAC,CAAC;AAE/D,eAAO,MAAM,4BAA4B;;MAEvC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAChC,OAAO,4BAA4B,CAAC,QAAQ,CAAC;AAS/C,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;MASD,CAAC;AACtC,MAAM,MAAM,mBAAmB,GAAG,OAAO,yBAAyB,CAAC,QAAQ,CAAC;AAE5E,eAAO,MAAM,+BAA+B;;;;;;;;;MAID,CAAC;AAC5C,MAAM,MAAM,yBAAyB,GACnC,OAAO,+BAA+B,CAAC,QAAQ,CAAC;AAElD,eAAO,MAAM,+BAA+B;;;;;;;;MAGD,CAAC;AAC5C,MAAM,MAAM,yBAAyB,GACnC,OAAO,+BAA+B,CAAC,QAAQ,CAAC;AAElD;;GAEG;AAEH,eAAO,MAAM,sCAAsC;;;;MAMhD,CAAC;AACJ,MAAM,MAAM,gCAAgC,GAC1C,OAAO,sCAAsC,CAAC,QAAQ,CAAC"}

package/dist/esm/customer/{schema/organization.js → organization/schema.js}

@@ -1,12 +1,11 @@
 import { type } from 'arktype';
 import { OptionalDatePayloadSchema, RequiredDatePayloadSchema, } from '../../common/index.js';
-import { MetadataPayloadPropertySchema, UpsertMetadataPayloadPropertySchema, } from '../../common/schema/metadata.js';
-import { generateOrganizationId } from './utils.js';
+import { MetadataPayloadPropertySchema, UpsertMetadataPropertyPayloadSchema, } from '../../common/schema/metadata.js';
+import { OrganizationIdSchema, generateOrganizationId } from '../schema.js';
 export const OrganizationStatus = {
     ACTIVE: 'active',
     SUSPENDED: 'suspended',
 };
-export const OrganizationIdSchema = type.string;
 export const OrganizationIdPropertySchema = type({
     id: OrganizationIdSchema,
 });
@@ -26,11 +25,14 @@ export const InsertOrganizationPayloadSchema = type({
     id: OrganizationIdSchema.default(() => generateOrganizationId()),
     status: StatusSchema.optional(),
     name: OrganizationNameSchema,
-}).and(UpsertMetadataPayloadPropertySchema);
+}).and(UpsertMetadataPropertyPayloadSchema);
 export const UpdateOrganizationPayloadSchema = type({
     status: StatusSchema.or(type.null).optional(),
     name: OrganizationNameSchema.or(type.null).optional(),
-}).and(UpsertMetadataPayloadPropertySchema);
+}).and(UpsertMetadataPropertyPayloadSchema);
+/**
+ * Association
+ */
 export const OrganizationAssociationReferenceSchema = OrganizationIdPropertySchema.and(type({
     name: type.string,
     model: "'Organization'",

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

@@ -0,0 +1,17 @@
+export declare const Model: {
+    readonly Organization: {
+        readonly UIDPrefix: "org";
+    };
+    readonly User: {
+        readonly UIDPrefix: "usr";
+    };
+};
+export declare function generateUserId(): string;
+export declare function generateOrganizationId(): string;
+export declare const UserIdSchema: import("arktype/internal/methods/string.ts").StringType<string, {}>;
+export type UserId = typeof UserIdSchema.inferOut;
+export declare const UserIdAssociationsSchema: import("arktype").BaseType<string[] | undefined, {}>;
+export declare const OrganizationIdSchema: import("arktype/internal/methods/string.ts").StringType<string, {}>;
+export type OrganizationId = typeof OrganizationIdSchema.inferOut;
+export declare const OrganizationIdAssociationsSchema: import("arktype").BaseType<string[] | undefined, {}>;
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/customer/schema.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,KAAK;;;;;;;CAOR,CAAC;AAEX,wBAAgB,cAAc,WAE7B;AAED,wBAAgB,sBAAsB,WAErC;AAED,eAAO,MAAM,YAAY,qEAAoC,CAAC;AAC9D,MAAM,MAAM,MAAM,GAAG,OAAO,YAAY,CAAC,QAAQ,CAAC;AAElD,eAAO,MAAM,wBAAwB,sDAEpC,CAAC;AAEF,eAAO,MAAM,oBAAoB,qEAA4C,CAAC;AAC9E,MAAM,MAAM,cAAc,GAAG,OAAO,oBAAoB,CAAC,QAAQ,CAAC;AAElE,eAAO,MAAM,gCAAgC,sDAE5C,CAAC"}

package/dist/esm/customer/schema.js

@@ -0,0 +1,21 @@
+import { type } from 'arktype';
+import KSUID from 'ksuid';
+import { KSUIDSchema } from '../common/schema/id.js';
+export const Model = {
+    Organization: {
+        UIDPrefix: 'org',
+    },
+    User: {
+        UIDPrefix: 'usr',
+    },
+};
+export function generateUserId() {
+    return `${Model.User.UIDPrefix}_${KSUID.randomSync().string}`;
+}
+export function generateOrganizationId() {
+    return `${Model.Organization.UIDPrefix}_${KSUID.randomSync().string}`;
+}
+export const UserIdSchema = KSUIDSchema(Model.User.UIDPrefix);
+export const UserIdAssociationsSchema = type('undefined').or(UserIdSchema.array());
+export const OrganizationIdSchema = KSUIDSchema(Model.Organization.UIDPrefix);
+export const OrganizationIdAssociationsSchema = type('undefined').or(OrganizationIdSchema.array());

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

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

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

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

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

@@ -0,0 +1,40 @@
+import { describe, expect, test } from 'vitest';
+import { Model, generateOrganizationId, generateUserId } from './schema.js';
+describe('Customer Schema - Utils', () => {
+    describe('Model constants', () => {
+        test('should have correct UID prefixes', () => {
+            expect(Model.Organization.UIDPrefix).toBe('org');
+            expect(Model.User.UIDPrefix).toBe('usr');
+        });
+    });
+    describe('generateUserId', () => {
+        test('should generate ID with correct prefix', () => {
+            const id = generateUserId();
+            expect(id).toMatch(/^usr_[A-Za-z0-9]+$/);
+        });
+        test('should generate unique IDs', () => {
+            const id1 = generateUserId();
+            const id2 = generateUserId();
+            expect(id1).not.toBe(id2);
+        });
+        test('should generate IDs with correct length', () => {
+            const id = generateUserId();
+            expect(id.length).toBeGreaterThan(4); // prefix + underscore + KSUID
+        });
+    });
+    describe('generateOrganizationId', () => {
+        test('should generate ID with correct prefix', () => {
+            const id = generateOrganizationId();
+            expect(id).toMatch(/^org_[A-Za-z0-9]+$/);
+        });
+        test('should generate unique IDs', () => {
+            const id1 = generateOrganizationId();
+            const id2 = generateOrganizationId();
+            expect(id1).not.toBe(id2);
+        });
+        test('should generate IDs with correct length', () => {
+            const id = generateOrganizationId();
+            expect(id.length).toBeGreaterThan(4); // prefix + underscore + KSUID
+        });
+    });
+});

package/dist/esm/customer/users/schema.d.ts

@@ -23,8 +23,6 @@ export declare const UpdateUserNamePropertiesSchema: import("arktype/internal/me
     honorificPrefix?: string | null | undefined;
     honorificSuffix?: string | null | undefined;
 }, {}>;
-export declare const UserIdSchema: import("arktype/internal/methods/string.ts").StringType<string, {}>;
-export type UserId = typeof UserIdSchema.inferOut;
 export declare const UserIdPropertySchema: import("arktype/internal/methods/object.ts").ObjectType<{
     id: string;
 }, {}>;
@@ -66,7 +64,7 @@ export declare const UserSchema: import("arktype/internal/methods/object.ts").Ob
     lastLogin?: 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 UserProperties = typeof UserSchema.inferIn;
 export type User = typeof UserSchema.inferOut;
@@ -133,6 +131,9 @@ export declare const UpdateUserPayloadSchema: import("arktype/internal/methods/o
 }, {}>;
 export type UpdateUserInput = typeof UpdateUserPayloadSchema.inferIn;
 export type UpdateUserPayload = typeof UpdateUserPayloadSchema.inferOut;
+/**
+ * Association
+ */
 export declare const UserAssociationReferenceSchema: import("arktype/internal/methods/object.ts").ObjectType<{
     id: string;
     givenName?: string | undefined;

package/dist/esm/customer/users/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/customer/users/schema.ts"],"names":[],"mappings":"AAmBA,eAAO,MAAM,mBAAmB;;;CAGtB,CAAC;AAEX,MAAM,MAAM,sBAAsB,GAChC,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,OAAO,mBAAmB,CAAC,CAAC;AAEjE,eAAO,MAAM,UAAU;;;;CAIb,CAAC;AACX,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,OAAO,UAAU,CAAC,CAAC;AAQzE,eAAO,MAAM,wBAAwB;;;;;;MAMnC,CAAC;AAGH,eAAO,MAAM,8BAA8B;;;;;;MAMzC,CAAC;AAGH,eAAO,MAAM,YAAY,qEAAc,CAAC;AACxC,MAAM,MAAM,MAAM,GAAG,OAAO,YAAY,CAAC,QAAQ,CAAC;AAElD,eAAO,MAAM,oBAAoB;;MAE/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,oBAAoB,CAAC,QAAQ,CAAC;AAElE,eAAO,MAAM,mBAAmB,qEAAuB,CAAC;AACxD,eAAO,MAAM,yBAAyB,qEAAiB,CAAC;AAExD,eAAO,MAAM,oCAAoC;;;;;MAK/C,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;MAGvC,CAAC;AAIH,eAAO,MAAM,sBAAsB;;MAEjC,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,OAAO,sBAAsB,CAAC,QAAQ,CAAC;AAStE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;MAMU,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;;;;;;;;;;;;;;;;;;;;;;;;;;MAMO,CAAC;AACtC,MAAM,MAAM,WAAW,GAAG,OAAO,iBAAiB,CAAC,QAAQ,CAAC;AAE5D,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;MAMO,CAAC;AAC5C,MAAM,MAAM,eAAe,GAAG,OAAO,uBAAuB,CAAC,OAAO,CAAC;AACrE,MAAM,MAAM,iBAAiB,GAAG,OAAO,uBAAuB,CAAC,QAAQ,CAAC;AAExE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;MAIO,CAAC;AAC5C,MAAM,MAAM,eAAe,GAAG,OAAO,uBAAuB,CAAC,OAAO,CAAC;AACrE,MAAM,MAAM,iBAAiB,GAAG,OAAO,uBAAuB,CAAC,QAAQ,CAAC;AAExE,eAAO,MAAM,8BAA8B;;;;;;;;;;;MAS1C,CAAC;AACF,MAAM,MAAM,wBAAwB,GAClC,OAAO,8BAA8B,CAAC,QAAQ,CAAC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/customer/users/schema.ts"],"names":[],"mappings":"AAqBA,eAAO,MAAM,mBAAmB;;;CAGtB,CAAC;AAEX,MAAM,MAAM,sBAAsB,GAChC,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,OAAO,mBAAmB,CAAC,CAAC;AAEjE,eAAO,MAAM,UAAU;;;;CAIb,CAAC;AACX,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,OAAO,UAAU,CAAC,CAAC;AAQzE,eAAO,MAAM,wBAAwB;;;;;;MAMnC,CAAC;AAGH,eAAO,MAAM,8BAA8B;;;;;;MAMzC,CAAC;AAGH,eAAO,MAAM,oBAAoB;;MAE/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,oBAAoB,CAAC,QAAQ,CAAC;AAElE,eAAO,MAAM,mBAAmB,qEAAuB,CAAC;AACxD,eAAO,MAAM,yBAAyB,qEAAiB,CAAC;AAExD,eAAO,MAAM,oCAAoC;;;;;MAK/C,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;MAGvC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;MAEjC,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,OAAO,sBAAsB,CAAC,QAAQ,CAAC;AAStE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;MAMU,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;;;;;;;;;;;;;;;;;;;;;;;;;;MAMO,CAAC;AACtC,MAAM,MAAM,WAAW,GAAG,OAAO,iBAAiB,CAAC,QAAQ,CAAC;AAE5D,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;MAMO,CAAC;AAC5C,MAAM,MAAM,eAAe,GAAG,OAAO,uBAAuB,CAAC,OAAO,CAAC;AACrE,MAAM,MAAM,iBAAiB,GAAG,OAAO,uBAAuB,CAAC,QAAQ,CAAC;AAExE,eAAO,MAAM,uBAAuB;;;;;;;;;;;;MAIO,CAAC;AAC5C,MAAM,MAAM,eAAe,GAAG,OAAO,uBAAuB,CAAC,OAAO,CAAC;AACrE,MAAM,MAAM,iBAAiB,GAAG,OAAO,uBAAuB,CAAC,QAAQ,CAAC;AAExE;;GAEG;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;MAS1C,CAAC;AACF,MAAM,MAAM,wBAAwB,GAClC,OAAO,8BAA8B,CAAC,QAAQ,CAAC"}

package/dist/esm/customer/users/schema.js

@@ -1,8 +1,10 @@
 import { type } from 'arktype';
+import { RoleIdAssociationsSchema } from '../../authorization/schema.js';
 import { AggregateSchema } from '../../common/schema/aggregate.js';
 import { OptionalDatePayloadSchema, OptionalDateSchema, RequiredDatePayloadSchema, RequiredDateSchema, } from '../../common/schema/dates.js';
-import { MetadataMapPropertySchema, MetadataPayloadPropertySchema, UpsertMetadataPayloadPropertySchema, } from '../../common/schema/metadata.js';
+import { MetadataMapPropertySchema, MetadataPayloadPropertySchema, UpsertMetadataPropertyPayloadSchema, } from '../../common/schema/metadata.js';
 import { optionallyNullish, optionallyNullishToUndefined, optionallyUndefined, } from '../../common/schema/schema.js';
+import { UserIdSchema } from '../schema.js';
 export const VerifiableAttribute = {
     EMAIL: 'email',
     PHONE_NUMBER: 'phoneNumber',
@@ -29,7 +31,6 @@ export const UpdateUserNamePropertiesSchema = type({
     honorificSuffix: optionallyNullish(type('string')),
 });
 // type UpsertUserNameProperties = typeof UpdateUserNamePropertiesSchema.inferOut;
-export const UserIdSchema = type.string;
 export const UserIdPropertySchema = type({
     id: UserIdSchema,
 });
@@ -45,9 +46,8 @@ export const EmailOrPhonePropertiesSchema = type({
     email: optionallyNullishToUndefined(RequiredEmailSchema),
     phoneNumber: optionallyNullishToUndefined(RequiredPhoneNumberSchema),
 });
-const UserRoleAssociationSchema = type('string[] | undefined');
 export const UserAssociationsSchema = type({
-    roles: UserRoleAssociationSchema.optional(),
+    roles: RoleIdAssociationsSchema.optional(),
 });
 const BaseSchema = UserIdPropertySchema.and(UserNamePropertiesSchema)
     .and(VerifiedEmailOrPhonePropertiesSchema)
@@ -75,12 +75,15 @@ export const InsertUserPayloadSchema = type({
     .and(UserNamePropertiesSchema)
     .and(VerifiedEmailOrPhonePropertiesSchema)
     .and(UserAssociationsSchema)
-    .and(UpsertMetadataPayloadPropertySchema);
+    .and(UpsertMetadataPropertyPayloadSchema);
 export const UpdateUserPayloadSchema = type({
     suspended: type.boolean.optional(),
 })
     .and(UpdateUserNamePropertiesSchema)
-    .and(UpsertMetadataPayloadPropertySchema);
+    .and(UpsertMetadataPropertyPayloadSchema);
+/**
+ * Association
+ */
 export const UserAssociationReferenceSchema = UserIdPropertySchema.and(UserNamePropertiesSchema).and(EmailOrPhonePropertiesSchema.and(type({
     status: UserStatusSchema.default('unverified'),
     model: "'User'",

package/dist/esm/customer/users/schema.test.js

@@ -1,12 +1,13 @@
 import { type } from 'arktype';
 import { describe, expect, test } from 'vitest';
+import { generateUserId } from '../schema.js';
 import { InsertUserPayloadSchema, UserPayloadSchema, UserStatus, } from './schema.js';
 describe('Customer - User', () => {
     describe('User Payload', () => {
         test('should parse attributes successfully', async () => {
             const item = {
                 foo: 'bar',
-                id: '123',
+                id: generateUserId(),
                 phoneNumber: '123',
                 status: UserStatus.ACTIVE,
                 createdAt: new Date(),
@@ -24,7 +25,7 @@ describe('Customer - User', () => {
         test('should parse attributes successfully', async () => {
             const item = {
                 foo: 'bar',
-                id: '123',
+                id: generateUserId(),
                 familyName: 'Foo',
                 phoneNumber: '123',
             };
@@ -39,7 +40,7 @@ describe('Customer - User', () => {
         test('should serialize successfully', async () => {
             const item = {
                 foo: 'bar',
-                id: '123',
+                id: generateUserId(),
                 phoneNumber: '123',
                 metadata: new Map(),
                 // status: UserStatus.ACTIVE,
@@ -55,7 +56,7 @@ describe('Customer - User', () => {
         });
         test('should serialize nulls successfully', async () => {
             const payload = {
-                id: '123',
+                id: generateUserId(),
                 status: 'unverified',
                 givenName: null,
                 middleName: null,
@@ -77,7 +78,7 @@ describe('Customer - User', () => {
         });
         test('should serialize nulls successfully', async () => {
             const payload = {
-                id: '123',
+                id: generateUserId(),
                 status: 'unverified',
                 givenName: null,
                 middleName: null,

package/dist/esm/customer/users/utils.test.d.ts

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

package/dist/esm/customer/users/utils.test.d.ts.map

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

package/dist/esm/customer/users/utils.test.js

@@ -0,0 +1,143 @@
+import { describe, expect, test } from 'vitest';
+import { getInitials, buildName, buildProperName, buildReference, } from './utils.js';
+describe('Customer Users - Utils', () => {
+    describe('getInitials', () => {
+        test('should return initials for single name', () => {
+            expect(getInitials('John')).toBe('J');
+        });
+        test('should return initials for full name', () => {
+            expect(getInitials('John Doe')).toBe('JD');
+        });
+        test('should return initials for multiple names', () => {
+            expect(getInitials('John Michael Doe')).toBe('JMD');
+        });
+        test('should handle names with extra spaces', () => {
+            expect(getInitials('John  Doe')).toBe('JD');
+            expect(getInitials(' John Doe ')).toBe('JD');
+        });
+        test('should return undefined for empty string', () => {
+            expect(getInitials('')).toBeUndefined();
+        });
+        test('should return undefined for undefined input', () => {
+            expect(getInitials(undefined)).toBeUndefined();
+        });
+        test('should handle single character names', () => {
+            expect(getInitials('A B C')).toBe('ABC');
+        });
+        test('should filter out empty parts', () => {
+            expect(getInitials('John  Doe')).toBe('JD');
+        });
+    });
+    describe('buildName', () => {
+        test('should build name from givenName and familyName', () => {
+            const item = { givenName: 'John', familyName: 'Doe' };
+            expect(buildName(item)).toBe('John Doe');
+        });
+        test('should handle only givenName', () => {
+            const item = { givenName: 'John' };
+            expect(buildName(item)).toBe('John');
+        });
+        test('should handle only familyName', () => {
+            const item = { familyName: 'Doe' };
+            expect(buildName(item)).toBe('Doe');
+        });
+        test('should return empty string for empty object', () => {
+            expect(buildName({})).toBe('');
+        });
+        test('should return empty string for undefined', () => {
+            expect(buildName(undefined)).toBe('');
+        });
+        test('should filter out empty strings', () => {
+            const item = { givenName: 'John', familyName: '' };
+            expect(buildName(item)).toBe('John');
+        });
+    });
+    describe('buildProperName', () => {
+        test('should build proper name with all components', () => {
+            const item = {
+                honorificPrefix: 'Dr.',
+                givenName: 'John',
+                middleName: 'Michael',
+                familyName: 'Doe',
+                honorificSuffix: 'Jr.',
+            };
+            expect(buildProperName(item, true)).toBe('Dr. John Michael Doe Jr.');
+        });
+        test('should exclude middle name by default', () => {
+            const item = {
+                honorificPrefix: 'Dr.',
+                givenName: 'John',
+                middleName: 'Michael',
+                familyName: 'Doe',
+                honorificSuffix: 'Jr.',
+            };
+            expect(buildProperName(item)).toBe('Dr. John Doe Jr.');
+        });
+        test('should handle missing components', () => {
+            const item = {
+                givenName: 'John',
+                familyName: 'Doe',
+            };
+            expect(buildProperName(item)).toBe('John Doe');
+        });
+        test('should handle only prefix and suffix', () => {
+            const item = {
+                honorificPrefix: 'Dr.',
+                honorificSuffix: 'PhD',
+            };
+            expect(buildProperName(item)).toBe('Dr. PhD');
+        });
+        test('should return empty string for empty object', () => {
+            expect(buildProperName({})).toBe('');
+        });
+        test('should return empty string for undefined', () => {
+            expect(buildProperName(undefined)).toBe('');
+        });
+        test('should include middle name when explicitly requested', () => {
+            const item = {
+                givenName: 'John',
+                middleName: 'Michael',
+                familyName: 'Doe',
+            };
+            expect(buildProperName(item, true)).toBe('John Michael Doe');
+            expect(buildProperName(item, false)).toBe('John Doe');
+        });
+    });
+    describe('buildReference', () => {
+        test('should prioritize name over email', () => {
+            const item = {
+                givenName: 'John',
+                familyName: 'Doe',
+                email: 'john@example.com',
+            };
+            expect(buildReference(item)).toBe('John Doe');
+        });
+        test('should fallback to email when no name', () => {
+            const item = {
+                email: 'john@example.com',
+            };
+            expect(buildReference(item)).toBe('john@example.com');
+        });
+        test('should return empty string when no name or email', () => {
+            const item = {};
+            expect(buildReference(item)).toBe('');
+        });
+        test('should return empty string for undefined', () => {
+            expect(buildReference(undefined)).toBe('');
+        });
+        test('should use partial name if available', () => {
+            const item = {
+                givenName: 'John',
+                email: 'john@example.com',
+            };
+            expect(buildReference(item)).toBe('John');
+        });
+        test('should prefer family name over email if no given name', () => {
+            const item = {
+                familyName: 'Doe',
+                email: 'john@example.com',
+            };
+            expect(buildReference(item)).toBe('Doe');
+        });
+    });
+});

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

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

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

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

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

@@ -0,0 +1,38 @@
+import { type } from 'arktype';
+import { describe, expect, test } from 'vitest';
+import { IdentityIdentifier, IdentityIdentifierSchema } from './schema.js';
+describe('Identity - Schema', () => {
+    describe('IdentityIdentifier constants', () => {
+        test('should have correct identifier values', () => {
+            expect(IdentityIdentifier.EMAIL).toBe('email');
+            expect(IdentityIdentifier.PHONE_NUMBER).toBe('phoneNumber');
+        });
+    });
+    describe('IdentityIdentifierSchema', () => {
+        test('should accept valid email identifier', () => {
+            const result = IdentityIdentifierSchema('email');
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toBe('email');
+        });
+        test('should accept valid phone number identifier', () => {
+            const result = IdentityIdentifierSchema('phoneNumber');
+            expect(result).not.toBeInstanceOf(type.errors);
+            expect(result).toBe('phoneNumber');
+        });
+        test('should reject invalid identifiers', () => {
+            expect(IdentityIdentifierSchema('username')).toBeInstanceOf(type.errors);
+            expect(IdentityIdentifierSchema('invalid')).toBeInstanceOf(type.errors);
+            expect(IdentityIdentifierSchema('')).toBeInstanceOf(type.errors);
+        });
+        test('should reject non-string values', () => {
+            expect(IdentityIdentifierSchema(123)).toBeInstanceOf(type.errors);
+            expect(IdentityIdentifierSchema(null)).toBeInstanceOf(type.errors);
+            expect(IdentityIdentifierSchema(undefined)).toBeInstanceOf(type.errors);
+        });
+        test('should be case sensitive', () => {
+            expect(IdentityIdentifierSchema('Email')).toBeInstanceOf(type.errors);
+            expect(IdentityIdentifierSchema('PHONE_NUMBER')).toBeInstanceOf(type.errors);
+            expect(IdentityIdentifierSchema('phonenumber')).toBeInstanceOf(type.errors);
+        });
+    });
+});

package/dist/esm/oauth/authorize/schema/grants/authorization-code.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"authorization-code.d.ts","sourceRoot":"","sources":["../../../../../../src/oauth/authorize/schema/grants/authorization-code.ts"],"names":[],"mappings":"AAwCA,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;MAEd,CAAC;AACvB,MAAM,MAAM,wBAAwB,GAAG,OAAO,uBAAuB,CAAC,QAAQ,CAAC"}
+{"version":3,"file":"authorization-code.d.ts","sourceRoot":"","sources":["../../../../../../src/oauth/authorize/schema/grants/authorization-code.ts"],"names":[],"mappings":"AA8DA,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;MAEd,CAAC;AACvB,MAAM,MAAM,wBAAwB,GAAG,OAAO,uBAAuB,CAAC,QAAQ,CAAC"}

package/dist/esm/oauth/authorize/schema/grants/authorization-code.js

@@ -9,9 +9,28 @@ const ResponseTypeSchema = type.enumerated(ResponseType.CODE);
 const PKCESchema = type({
     code_challenge_method: CodeChallengeMethodSchema.optional(),
     code_challenge: type('string').optional(),
-}).or({
+})
+    .or({
     code_challenge_method: CodeChallengeMethodSchema,
-    code_challenge: type('string'),
+    code_challenge: type('string').moreThanLength(0),
+})
+    .narrow((data, ctx) => {
+    if ((data.code_challenge_method && data.code_challenge) ||
+        (!data.code_challenge_method && !data.code_challenge)) {
+        return true;
+    }
+    if (data.code_challenge_method && !data.code_challenge) {
+        return ctx.reject({
+            expected: 'is required',
+            actual: '',
+            path: ['code_challenge'],
+        });
+    }
+    return ctx.reject({
+        expected: 'is required',
+        actual: '',
+        path: ['code_challenge_method'],
+    });
 });
 const OAuthSchema = type({
     response_type: ResponseTypeSchema,
@@ -24,7 +43,7 @@ const OIDCSchema = type({
     nonce: type('string').optional(),
     display: AuthorizationDisplaySchema.optional(),
     prompt: AuthorizationPromptSchema.optional(),
-    max_age: type('number').optional(),
+    max_age: type.keywords.number.integer.atLeast(0).optional(),
 });
 export const AuthorizationCodeSchema = OAuthSchema.and(OIDCSchema)
     .and(PKCESchema)

package/dist/esm/oauth/authorize/schema/grants/authorization-code.test.d.ts

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

package/dist/esm/oauth/authorize/schema/grants/authorization-code.test.d.ts.map

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