@seamless-auth/types 0.1.0 → 0.1.1

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-export * from './schemas/user.schema';
-export * from './schemas/credential.schema';
-export * from './schemas/auth.schema';
-export * from './schemas/authEvent.schema';
-export * from './schemas/sessions.schema';
+export * from './schemas/user/schema';
+export * from './schemas/credential/schema';
+export * from './schemas/auth/auth.schema';
+export * from './schemas/authEvent/schema';
+export * from './schemas/session/schema';

package/dist/index.js

@@ -1,5 +1,5 @@
-export * from './schemas/user.schema';
-export * from './schemas/credential.schema';
-export * from './schemas/auth.schema';
-export * from './schemas/authEvent.schema';
-export * from './schemas/sessions.schema';
+export * from './schemas/user/schema';
+export * from './schemas/credential/schema';
+export * from './schemas/auth/auth.schema';
+export * from './schemas/authEvent/schema';
+export * from './schemas/session/schema';

package/dist/schemas/{authEvent.schema.js → authEvent/schema.js}

@@ -1,5 +1,5 @@
 import z from 'zod';
-import { IsoDate } from '../shared';
+import { IsoDate } from '../../shared';
 export const AuthEventSchema = z.object({
     id: z.string(),
     user_id: z.string().nullable().optional(),

package/dist/schemas/authEvent/schema.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/schemas/authEvent/schema.test.js

@@ -0,0 +1,71 @@
+import { describe, it, expect } from 'vitest';
+import { AuthEventSchema } from './schema';
+const now = new Date().toISOString();
+describe('AuthEventSchema', () => {
+    const baseEvent = {
+        id: 'event_123',
+        user_id: 'user_123',
+        type: 'login',
+        ip_address: '127.0.0.1',
+        user_agent: 'Mozilla/5.0',
+        metadata: {
+            device: 'desktop',
+            success: true,
+        },
+        created_at: now,
+        updated_at: now,
+    };
+    it('parses a valid auth event', () => {
+        expect(() => AuthEventSchema.parse(baseEvent)).not.toThrow();
+    });
+    it('allows nullable optional fields', () => {
+        const minimal = {
+            id: 'event_123',
+            type: 'login',
+            metadata: null,
+            created_at: now,
+            updated_at: now,
+        };
+        expect(() => AuthEventSchema.parse(minimal)).not.toThrow();
+    });
+    it('allows missing optional fields', () => {
+        const { ...rest } = baseEvent;
+        expect(() => AuthEventSchema.parse(rest)).not.toThrow();
+    });
+    it('fails if required fields are missing', () => {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { id, ...rest } = baseEvent;
+        expect(() => AuthEventSchema.parse(rest)).toThrow();
+    });
+    it('fails if metadata is not an object or null', () => {
+        expect(() => AuthEventSchema.parse({
+            ...baseEvent,
+            metadata: 'invalid',
+        })).toThrow();
+    });
+    it('allows metadata with arbitrary values', () => {
+        expect(() => AuthEventSchema.parse({
+            ...baseEvent,
+            metadata: {
+                string: 'value',
+                number: 123,
+                boolean: true,
+                nested: { key: 'value' },
+                array: [1, 2, 3],
+            },
+        })).not.toThrow();
+    });
+    it('fails on invalid ISO date', () => {
+        expect(() => AuthEventSchema.parse({
+            ...baseEvent,
+            created_at: 'not-a-date',
+        })).toThrow();
+    });
+    it('fails when metadata is undefined (not nullable)', () => {
+        const { ...rest } = baseEvent;
+        expect(() => AuthEventSchema.parse({
+            ...rest,
+            metadata: undefined,
+        })).toThrow();
+    });
+});

package/dist/schemas/{credential.schema.d.ts → credential/schema.d.ts}

@@ -1,10 +1,20 @@
 import z from 'zod';
 export declare const CredentialSchema: z.ZodObject<{
     id: z.ZodString;
-    transports: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
-    deviceType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    backedUp: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    userId: z.ZodString;
+    publicKey: z.ZodString;
     counter: z.ZodNumber;
+    transports: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        ble: "ble";
+        internal: "internal";
+        nfc: "nfc";
+        usb: "usb";
+    }>>>;
+    deviceType: z.ZodOptional<z.ZodEnum<{
+        singleDevice: "singleDevice";
+        multiDevice: "multiDevice";
+    }>>;
+    backedUp: z.ZodBoolean;
     friendlyName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     lastUsedAt: z.ZodOptional<z.ZodNullable<z.ZodPipe<z.ZodCoercedDate<unknown>, z.ZodTransform<string, Date>>>>;
     platform: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -29,10 +39,18 @@ export declare const CredentialApiSchema: z.ZodObject<{
     id: z.ZodString;
     browser: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     createdAt: z.ZodPipe<z.ZodCoercedDate<unknown>, z.ZodTransform<string, Date>>;
-    transports: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
-    deviceType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    backedUp: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
     counter: z.ZodNumber;
+    transports: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        ble: "ble";
+        internal: "internal";
+        nfc: "nfc";
+        usb: "usb";
+    }>>>;
+    deviceType: z.ZodOptional<z.ZodEnum<{
+        singleDevice: "singleDevice";
+        multiDevice: "multiDevice";
+    }>>;
+    backedUp: z.ZodBoolean;
     friendlyName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     lastUsedAt: z.ZodOptional<z.ZodNullable<z.ZodPipe<z.ZodCoercedDate<unknown>, z.ZodTransform<string, Date>>>>;
     deviceInfo: z.ZodOptional<z.ZodNullable<z.ZodString>>;

package/dist/schemas/{credential.schema.js → credential/schema.js}

@@ -1,11 +1,15 @@
 import z from 'zod';
-import { IsoDate } from '../shared';
+import { IsoDate } from '../../shared';
+const TransportSchema = z.enum(['usb', 'ble', 'nfc', 'internal']);
+const DeviceTypeSchema = z.enum(['singleDevice', 'multiDevice']);
 export const CredentialSchema = z.object({
     id: z.string(),
-    transports: z.array(z.string()).nullable().optional(),
-    deviceType: z.string().nullable().optional(),
-    backedUp: z.boolean().nullable().optional(),
+    userId: z.string(),
+    publicKey: z.string(),
     counter: z.number(),
+    transports: z.array(TransportSchema).optional(),
+    deviceType: DeviceTypeSchema.optional(),
+    backedUp: z.boolean(),
     friendlyName: z.string().nullable().optional(),
     lastUsedAt: IsoDate.nullable().optional(),
     platform: z.string().nullable().optional(),

package/dist/schemas/credential/schema.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/schemas/credential/schema.test.js

@@ -0,0 +1,74 @@
+import { describe, it, expect } from 'vitest';
+import { CredentialSchema } from './schema';
+const now = new Date().toISOString();
+describe('CredentialSchema', () => {
+    const baseCredential = {
+        id: 'credential_id_base64url',
+        userId: crypto.randomUUID(),
+        publicKey: 'public_key_base64url',
+        counter: 0,
+        transports: ['internal'],
+        deviceType: 'singleDevice',
+        backedUp: false,
+        friendlyName: 'My Device',
+        lastUsedAt: now,
+        platform: 'ios',
+        browser: 'safari',
+        deviceInfo: 'iPhone',
+        createdAt: now,
+        updatedAt: now,
+    };
+    it('parses a valid credential', () => {
+        expect(() => CredentialSchema.parse(baseCredential)).not.toThrow();
+    });
+    it('fails when required fields are missing', () => {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { id, ...rest } = baseCredential;
+        expect(() => CredentialSchema.parse(rest)).toThrow();
+    });
+    it('fails when publicKey is not a string', () => {
+        expect(() => CredentialSchema.parse({
+            ...baseCredential,
+            publicKey: 123,
+        })).toThrow();
+    });
+    it('allows optional metadata fields to be omitted', () => {
+        const { ...minimal } = baseCredential;
+        expect(() => CredentialSchema.parse(minimal)).not.toThrow();
+    });
+    it('allows nullable optional fields', () => {
+        expect(() => CredentialSchema.parse({
+            ...baseCredential,
+            friendlyName: null,
+            platform: null,
+            browser: null,
+            deviceInfo: null,
+        })).not.toThrow();
+    });
+    it('allows missing transports', () => {
+        const { ...rest } = baseCredential;
+        expect(() => CredentialSchema.parse(rest)).not.toThrow();
+    });
+    it('fails on invalid transport value', () => {
+        expect(() => CredentialSchema.parse({
+            ...baseCredential,
+            transports: ['invalid'],
+        })).toThrow();
+    });
+    it('fails on invalid deviceType', () => {
+        expect(() => CredentialSchema.parse({
+            ...baseCredential,
+            deviceType: 'invalidType',
+        })).toThrow();
+    });
+    it('fails on invalid ISO date', () => {
+        expect(() => CredentialSchema.parse({
+            ...baseCredential,
+            createdAt: 'not-a-date',
+        })).toThrow();
+    });
+    it('allows lastUsedAt to be omitted', () => {
+        const { ...rest } = baseCredential;
+        expect(() => CredentialSchema.parse(rest)).not.toThrow();
+    });
+});

package/dist/schemas/session/schema.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/schemas/session/schema.test.js

@@ -0,0 +1,61 @@
+import { describe, it, expect } from 'vitest';
+import { SessionSchema } from './schema';
+const now = new Date().toISOString();
+const later = new Date(Date.now() + 1000 * 60 * 60).toISOString();
+describe('SessionSchema', () => {
+    const baseSession = {
+        id: 'session_123',
+        deviceName: 'MacBook Pro',
+        ipAddress: '127.0.0.1',
+        userAgent: 'Mozilla/5.0',
+        lastUsedAt: now,
+        expiresAt: later,
+        current: true,
+    };
+    it('parses a valid session', () => {
+        expect(() => SessionSchema.parse(baseSession)).not.toThrow();
+    });
+    it('allows optional nullable fields to be omitted', () => {
+        const { ...minimal } = baseSession;
+        expect(() => SessionSchema.parse(minimal)).not.toThrow();
+    });
+    it('allows optional nullable fields to be null', () => {
+        expect(() => SessionSchema.parse({
+            ...baseSession,
+            deviceName: null,
+            ipAddress: null,
+            userAgent: null,
+        })).not.toThrow();
+    });
+    it('fails when required fields are missing', () => {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { id, ...rest } = baseSession;
+        expect(() => SessionSchema.parse(rest)).toThrow();
+    });
+    it('fails when current is not a boolean', () => {
+        expect(() => SessionSchema.parse({
+            ...baseSession,
+            current: 'true',
+        })).toThrow();
+    });
+    it('fails when lastUsedAt is not a string', () => {
+        expect(() => SessionSchema.parse({
+            ...baseSession,
+            lastUsedAt: 123,
+        })).toThrow();
+    });
+    it('fails when expiresAt is not a string', () => {
+        expect(() => SessionSchema.parse({
+            ...baseSession,
+            expiresAt: 123,
+        })).toThrow();
+    });
+    it('allows different valid session shapes', () => {
+        expect(() => SessionSchema.parse({
+            id: 'session_456',
+            lastUsedAt: now,
+            expiresAt: later,
+            current: false,
+        })).not.toThrow();
+    });
+});

package/dist/schemas/{user.schema.d.ts → user/schema.d.ts}

@@ -24,5 +24,5 @@ export declare const UpdateUserSchema: z.ZodObject<{
     phone: z.ZodOptional<z.ZodString>;
     emailVerified: z.ZodOptional<z.ZodBoolean>;
     phoneVerified: z.ZodOptional<z.ZodBoolean>;
-    roles: z.ZodArray<z.ZodString>;
+    roles: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;

package/dist/schemas/{user.schema.js → user/schema.js}

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { IsoDate } from '../shared';
+import { IsoDate } from '../../shared';
 export const RoleSchema = z.string().regex(/^(?!.*[_/\\\s])[A-Za-z0-9-]{1,31}$/);
 export const UserSchema = z.object({
     id: z.uuid(),
@@ -25,6 +25,6 @@ export const UpdateUserSchema = z
     phone: z.string().min(5).optional(),
     emailVerified: z.boolean().optional(),
     phoneVerified: z.boolean().optional(),
-    roles: z.array(RoleSchema).min(1),
+    roles: z.array(RoleSchema).min(1).optional(),
 })
     .strict();

package/dist/schemas/user/schema.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/schemas/user/schema.test.js

@@ -0,0 +1,115 @@
+import { describe, it, expect } from 'vitest';
+import { UserSchema, CreateUserSchema, UpdateUserSchema } from './schema';
+const now = new Date().toISOString();
+describe('UserSchema', () => {
+    const baseUser = {
+        id: crypto.randomUUID(),
+        email: 'test@example.com',
+        phone: '1234567890',
+        roles: ['user'],
+        revoked: false,
+        emailVerified: true,
+        phoneVerified: false,
+        verified: true,
+        lastLogin: now,
+        createdAt: now,
+        updatedAt: now,
+    };
+    it('parses a valid user', () => {
+        expect(() => UserSchema.parse(baseUser)).not.toThrow();
+    });
+    it('applies defaults when optional fields are missing', () => {
+        const minimal = {
+            id: crypto.randomUUID(),
+            email: 'test@example.com',
+            phone: '1234567890',
+            createdAt: now,
+        };
+        const parsed = UserSchema.parse(minimal);
+        expect(parsed.roles).toEqual([]);
+        expect(parsed.revoked).toBe(false);
+        expect(parsed.emailVerified).toBe(false);
+        expect(parsed.phoneVerified).toBe(false);
+        expect(parsed.verified).toBe(false);
+    });
+    it('fails on invalid email', () => {
+        expect(() => UserSchema.parse({
+            ...baseUser,
+            email: 'invalid-email',
+        })).toThrow();
+    });
+    it('fails on invalid role format', () => {
+        expect(() => UserSchema.parse({
+            ...baseUser,
+            roles: ['bad role'], // contains space
+        })).toThrow();
+    });
+    it('allows nullable lastLogin', () => {
+        expect(() => UserSchema.parse({
+            ...baseUser,
+            lastLogin: null,
+        })).not.toThrow();
+    });
+    it('allows missing optional fields', () => {
+        const { ...rest } = baseUser;
+        expect(() => UserSchema.parse(rest)).not.toThrow();
+    });
+});
+describe('CreateUserSchema', () => {
+    it('parses valid input', () => {
+        expect(() => CreateUserSchema.parse({
+            email: 'test@example.com',
+            phone: '1234567890',
+            roles: ['admin'],
+        })).not.toThrow();
+    });
+    it('fails if roles are empty', () => {
+        expect(() => CreateUserSchema.parse({
+            email: 'test@example.com',
+            phone: '1234567890',
+            roles: [],
+        })).toThrow();
+    });
+    it('fails on invalid email', () => {
+        expect(() => CreateUserSchema.parse({
+            email: 'bad-email',
+            phone: '1234567890',
+            roles: ['user'],
+        })).toThrow();
+    });
+    it('fails on invalid role format', () => {
+        expect(() => CreateUserSchema.parse({
+            email: 'test@example.com',
+            phone: '1234567890',
+            roles: ['bad role'],
+        })).toThrow();
+    });
+});
+describe('UpdateUserSchema', () => {
+    it('parses valid partial update', () => {
+        expect(() => UpdateUserSchema.parse({
+            email: 'new@example.com',
+        })).not.toThrow();
+    });
+    it('requires roles if provided and must be non-empty', () => {
+        expect(() => UpdateUserSchema.parse({
+            roles: [],
+        })).toThrow();
+    });
+    it('fails on short phone number', () => {
+        expect(() => UpdateUserSchema.parse({
+            phone: '123',
+        })).toThrow();
+    });
+    it('fails on invalid role format', () => {
+        expect(() => UpdateUserSchema.parse({
+            roles: ['invalid role'],
+        })).toThrow();
+    });
+    it('fails on unknown fields due to strict()', () => {
+        expect(() => UpdateUserSchema.parse({
+            email: 'test@example.com',
+            unknownField: true,
+        })).toThrow();
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seamless-auth/types",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Shared TypeScript types and Zod schemas for SeamlessAuth.",
   "author": "Fells Code, LLC",
   "license": "AGPL-3.0",
@@ -8,10 +8,7 @@
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    }
+    ".": "./dist/index.js"
   },
   "files": [
     "dist"
@@ -43,7 +40,9 @@
     "format": "prettier --write .",
     "format:check": "prettier --check .",
     "prepare": "husky",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "lint-staged": {
     "*.ts": [
@@ -64,7 +63,8 @@
     "husky": "^9.1.7",
     "lint-staged": "^16.4.0",
     "prettier": "^3.8.1",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.1"
   },
   "engines": {
     "node": ">=20"
@@ -72,4 +72,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}