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

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

@@ -0,0 +1,27 @@
+export function getInitials(name) {
+    if (!name) {
+        return undefined;
+    }
+    return name
+        .split(' ')
+        .map((n) => n[0])
+        .filter(Boolean)
+        .join('');
+}
+export function buildName(item) {
+    return [item?.givenName, item?.familyName].filter(Boolean).join(' ');
+}
+export function buildProperName(item, includeMiddleName = false) {
+    return [
+        item?.honorificPrefix,
+        item?.givenName,
+        includeMiddleName ? item?.middleName : undefined,
+        item?.familyName,
+        item?.honorificSuffix,
+    ]
+        .filter(Boolean)
+        .join(' ');
+}
+export function buildReference(item) {
+    return buildName(item) || item?.email || '';
+}

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

@@ -0,0 +1,2 @@
+export * from './schema.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/identity/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC"}

package/dist/esm/identity/index.js

@@ -0,0 +1 @@
+export * from './schema.js';

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

@@ -0,0 +1,7 @@
+export declare const IdentityIdentifier: {
+    readonly EMAIL: "email";
+    readonly PHONE_NUMBER: "phoneNumber";
+};
+export type AnyIdentityIdentifier = (typeof IdentityIdentifier)[keyof typeof IdentityIdentifier];
+export declare const IdentityIdentifierSchema: import("arktype/internal/methods/string.ts").StringType<"email" | "phoneNumber", {}>;
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/identity/schema.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,kBAAkB;;;CAGrB,CAAC;AAEX,MAAM,MAAM,qBAAqB,GAC/B,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,OAAO,kBAAkB,CAAC,CAAC;AAE/D,eAAO,MAAM,wBAAwB,sFAGpC,CAAC"}

package/dist/esm/identity/schema.js

@@ -0,0 +1,6 @@
+import { type } from 'arktype';
+export const IdentityIdentifier = {
+    EMAIL: 'email',
+    PHONE_NUMBER: 'phoneNumber',
+};
+export const IdentityIdentifierSchema = type.enumerated(IdentityIdentifier.EMAIL, IdentityIdentifier.PHONE_NUMBER);

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

@@ -0,0 +1,2 @@
+export * from './schema/schema.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/oauth/authorize/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/oauth/authorize/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}

package/dist/esm/oauth/authorize/index.js

@@ -0,0 +1 @@
+export * from './schema/schema.js';

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

@@ -0,0 +1,29 @@
+export declare const AuthorizationCodeSchema: import("arktype/internal/methods/object.ts").ObjectType<{
+    response_type: "code";
+    client_id: string;
+    redirect_uri?: string | undefined;
+    scope?: string | undefined;
+    state?: string | undefined;
+    nonce?: string | undefined;
+    display?: "page" | "popup" | "touch" | "wap" | undefined;
+    prompt?: "none" | "login" | "consent" | "select_account" | undefined;
+    max_age?: number | undefined;
+    code_challenge_method?: "S256" | "plain" | undefined;
+    code_challenge?: string | undefined;
+    audience?: string | undefined;
+} | {
+    response_type: "code";
+    client_id: string;
+    redirect_uri?: string | undefined;
+    scope?: string | undefined;
+    state?: string | undefined;
+    nonce?: string | undefined;
+    display?: "page" | "popup" | "touch" | "wap" | undefined;
+    prompt?: "none" | "login" | "consent" | "select_account" | undefined;
+    max_age?: number | undefined;
+    code_challenge_method: "S256" | "plain";
+    code_challenge: string;
+    audience?: string | undefined;
+}, {}>;
+export type AuthorizationCodePayload = typeof AuthorizationCodeSchema.inferOut;
+//# sourceMappingURL=authorization-code.d.ts.map

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

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

@@ -0,0 +1,50 @@
+import { type } from 'arktype';
+import { AppIdSchema } from '../../../../app/schema.js';
+import { AuthorizationDisplaySchema, AuthorizationPromptSchema, CodeChallengeMethodSchema, OptionalSchema, ResponseType, } from '../../../common/schema.js';
+/**
+ * @see https://datatracker.ietf.org/doc/html/rfc6749#section-4.1.1
+ * @see https://openid.net/specs/openid-connect-core-1_0.html#rfc.section.3.1.2.1
+ */
+const ResponseTypeSchema = type.enumerated(ResponseType.CODE);
+const PKCESchema = type({
+    code_challenge_method: CodeChallengeMethodSchema.optional(),
+    code_challenge: type('string').optional(),
+})
+    .or({
+    code_challenge_method: CodeChallengeMethodSchema,
+    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,
+    client_id: AppIdSchema,
+    redirect_uri: type('string.url').optional(),
+    scope: type('string').optional(),
+    state: type('string').optional(),
+});
+const OIDCSchema = type({
+    nonce: type('string').optional(),
+    display: AuthorizationDisplaySchema.optional(),
+    prompt: AuthorizationPromptSchema.optional(),
+    max_age: type.keywords.number.integer.atLeast(0).optional(),
+});
+export const AuthorizationCodeSchema = OAuthSchema.and(OIDCSchema)
+    .and(PKCESchema)
+    .and(OptionalSchema);

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