@marcoappio/marco-config 4.0.26 → 6.0.0

package/dist/appwrite/appwrite.test.js

@@ -1,901 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import { v } from '../utils/valibot/index.js';
-import { appwrite } from './appwrite.js';
-import { appwriteTableIds } from './tableContract/index.js';
-const metadata = {
-    $createdAt: '2026-07-15T00:00:00.000Z',
-    $databaseId: 'marco',
-    $id: 'row-1',
-    $permissions: ['read("user:user-1")'],
-    $sequence: '1',
-    $updatedAt: '2026-07-15T00:00:00.000Z',
-};
-const rowFixture = (table, data, permissions = metadata.$permissions) => ({
-    ...metadata,
-    $permissions: permissions,
-    $tableId: appwrite.ids.tables[table],
-    ...data,
-});
-const validRows = {
-    accounts: rowFixture('accounts', {
-        colour: '#000000',
-        credential: null,
-        displayName: null,
-        initialSyncCompletedAt: null,
-        lastErrorCode: null,
-        lastSuccessfulSyncAt: null,
-        mailboxSyncState: null,
-        mailProcessedCount: 0,
-        mailTotalCount: 0,
-        pollShardAssignmentId: null,
-        pollShardId: null,
-        primaryAlias: 'alias-1',
-        primaryEmail: 'marco@example.com',
-        profile: 'user-1',
-        profileAssignmentKey: 'user-1',
-        provider: 'GMAIL',
-        state: 'CONNECTED',
-    }),
-    aliases: rowFixture('aliases', {
-        account: 'account-1',
-        accountAssignmentKey: 'account-1',
-        email: 'marco@example.com',
-        isPrimary: true,
-        name: 'Marco',
-        providerId: 'provider-1',
-        signature: '<p>Test signature</p>',
-    }),
-    commands: rowFixture('commands', {
-        account: null,
-        accountId: null,
-        attempts: 0,
-        canonicalRevision: null,
-        draftId: null,
-        errorCode: null,
-        kind: 'thread.archive',
-        payload: '{"threadId":"thread-1"}',
-        payloadHash: 'hash-1',
-        profile: 'user-1',
-        state: 'ACCEPTED',
-        submittedAt: '2026-07-15T00:00:00.000Z',
-        userId: 'user-1',
-    }),
-    contacts: rowFixture('contacts', {
-        displayName: 'Marco',
-        lastContactedAt: '2026-07-15T00:00:00.000Z',
-        messageCount: 0,
-        normalisedAddress: 'marco@example.com',
-        profile: 'user-1',
-        profileAssignmentKey: 'user-1',
-        searchText: 'marco',
-    }),
-    credentials: rowFixture('credentials', {
-        accountId: 'account-1',
-        encryptedPayload: 'encrypted-payload',
-        expiresAt: null,
-        provider: 'GMAIL',
-        refreshLeaseExpiresAt: null,
-        refreshLeaseId: null,
-        userId: 'user-1',
-    }),
-    drafts: rowFixture('drafts', {
-        account: 'account-1',
-        accountAssignmentKey: 'account-1',
-        attachmentMetadata: '[]',
-        contentHash: 'hash-1',
-        envelope: '{"bcc":[],"cc":[],"subject":null,"to":[]}',
-        errorCode: null,
-        executionLeaseExpiresAt: null,
-        executionLeaseId: null,
-        fromAlias: null,
-        html: '<p>Draft</p>',
-        referencedMessage: null,
-        revision: 0,
-        scheduledAt: null,
-        sequence: 0,
-        status: 'DRAFT',
-        type: 'COMPOSE',
-    }),
-    jobs: rowFixture('jobs', {
-        accountId: null,
-        attempts: 0,
-        commandId: 'command-1',
-        dedupeKey: 'dedupe-1',
-        errorCode: null,
-        kind: 'thread.archive',
-        leaseExpiresAt: null,
-        leaseId: null,
-        maxAttempts: 3,
-        nextRunAt: '2026-07-15T00:00:00.000Z',
-        payload: '{"threadId":"thread-1"}',
-        state: 'PENDING',
-        userId: 'user-1',
-    }),
-    labels: rowFixture('labels', {
-        account: 'account-1',
-        accountAssignmentKey: 'account-1',
-        name: null,
-        path: 'Inbox',
-        providerId: 'provider-1',
-        specialUse: 'INBOX',
-        totalCount: 0,
-        unreadCount: 0,
-    }),
-    mailboxSyncCandidates: rowFixture('mailboxSyncCandidates', {
-        account: 'account-1',
-        accountId: 'account-1',
-        generation: 1,
-        label: 'label-1',
-        labelId: 'label-1',
-        lane: 'HEAD',
-        mailboxPath: 'INBOX',
-        mailboxPriority: 1,
-        mailboxSortKey: '0000000001:INBOX',
-        providerId: 'provider-message-1',
-        receivedAt: '2026-07-15T00:00:00.000Z',
-        specialUse: 'INBOX',
-        uid: 1,
-        uidValidity: 1,
-        userId: 'user-1',
-    }),
-    mailboxSyncLanes: rowFixture('mailboxSyncLanes', {
-        account: 'test-account-id-1',
-        accountId: 'test-account-id-1',
-        commandId: 'sync_test-command-id-1',
-        cursor: null,
-        errorCode: null,
-        generation: 1,
-        lane: 'HEAD',
-        state: 'RUNNING',
-        userId: 'test-user-id-1',
-    }, []),
-    mailboxSyncStates: rowFixture('mailboxSyncStates', {
-        accountId: 'account-1',
-        errorCode: null,
-        lastEventAt: null,
-        lastSyncAt: null,
-        materialisationLeaseExpiresAt: null,
-        materialisationLeaseId: null,
-        nextPollAt: null,
-        provider: 'GMAIL',
-        providerCursor: null,
-        state: 'CURRENT',
-        uidValidity: null,
-        userId: 'user-1',
-    }),
-    messageLocations: rowFixture('messageLocations', {
-        account: 'account-1',
-        accountAssignmentKey: 'account-1',
-        flagged: false,
-        label: 'label-1',
-        labelAssignmentKey: 'label-1',
-        message: 'message-1',
-        messageAt: '2026-07-15T00:00:00.000Z',
-        seen: true,
-        thread: 'thread-1',
-        threadAssignmentKey: 'thread-1',
-        uid: 1,
-        uidValidity: 1,
-    }),
-    messages: rowFixture('messages', {
-        account: 'account-1',
-        accountAssignmentKey: 'account-1',
-        attachmentMetadata: '[]',
-        htmlFileId: null,
-        materialisationGeneration: 1,
-        preview: 'Preview',
-        providerHistoryId: '987654321',
-        providerId: 'provider-1',
-        providerLabelIds: ['INBOX'],
-        providerThreadId: 'provider-thread-1',
-        rawFileId: null,
-        receivedAt: null,
-        recipients: '[{"emailAddress":"recipient@example.com","name":"Recipient","type":"to"}]',
-        revision: 0,
-        rfcMessageId: null,
-        sender: 'marco@example.com',
-        senderName: 'Marco',
-        sentAt: '2026-07-15T00:00:00.000Z',
-        size: 1,
-        subject: 'Test subject',
-        thread: 'thread-1',
-        threadAssignmentKey: 'thread-1',
-    }),
-    oauthStates: rowFixture('oauthStates', {
-        accountId: 'account-1',
-        email: 'marco@example.com',
-        expiresAt: '2026-07-15T00:10:00.000Z',
-        nonceHash: 'test-nonce-hash-1',
-        operation: 'CONNECT',
-        profile: 'user-1',
-        provider: 'GMAIL',
-        returnUri: 'https://app.marcoapp.io/onboarding/loading',
-        userId: 'user-1',
-    }),
-    pollShardCoordinators: rowFixture('pollShardCoordinators', {
-        accountCursor: null,
-    }, []),
-    pollShards: rowFixture('pollShards', {
-        accountIds: ['test-account-id-1'],
-        errorCode: null,
-        generation: 1,
-        lastStartedAt: null,
-        leaseExpiresAt: null,
-        leaseId: null,
-        nextStartAt: '2026-07-15T00:00:30.000Z',
-        pollingSnapshot: '{"members":[],"version":1}',
-        scheduledExecutionId: null,
-        state: 'ACTIVE',
-    }, []),
-    profileAvatarCleanups: rowFixture('profileAvatarCleanups', {
-        claimedAt: null,
-        claimId: null,
-        fileId: 'test-file-id-1',
-        profile: 'user-1',
-    }, []),
-    profiles: rowFixture('profiles', {
-        avatarFileId: null,
-        deletionRequestedAt: null,
-        email: 'marco@example.com',
-        name: null,
-        onboardingState: null,
-        timezone: null,
-    }),
-    pushNotificationTokens: rowFixture('pushNotificationTokens', {
-        profile: 'user-1',
-        token: 'ExponentPushToken[token]',
-        userId: 'user-1',
-    }),
-    savedViews: rowFixture('savedViews', {
-        aliasIds: ['alias-1'],
-        icon: 'mail',
-        name: 'Unread',
-        profile: 'user-1',
-    }),
-    threadAliases: rowFixture('threadAliases', {
-        alias: 'alias-1',
-        aliasAssignmentKey: 'alias-1',
-        latestMessageAt: '2026-07-15T00:00:00.000Z',
-        thread: 'thread-1',
-        threadAssignmentKey: 'thread-1',
-    }),
-    threadLabels: rowFixture('threadLabels', {
-        label: 'label-1',
-        labelAssignmentKey: 'label-1',
-        latestMessageAt: '2026-07-15T00:00:00.000Z',
-        locationCount: 1,
-        thread: 'thread-1',
-        threadAssignmentKey: 'thread-1',
-    }),
-    threads: rowFixture('threads', {
-        account: 'account-1',
-        accountAssignmentKey: 'account-1',
-        archived: false,
-        firstMessageAt: '2026-07-14T00:00:00.000Z',
-        flagged: false,
-        flaggedLocationCount: 0,
-        hasAttachments: false,
-        labelIds: ['label-1'],
-        latestMessageAt: '2026-07-15T00:00:00.000Z',
-        latestMessageId: 'message-1',
-        messageCount: 1,
-        participants: 'sender@example.com recipient@example.com',
-        preview: 'Preview',
-        providerId: 'provider-1',
-        revision: 0,
-        searchText: 'preview',
-        seen: true,
-        senderEmail: 'sender@example.com',
-        senderName: 'Sender',
-        snoozedUntil: null,
-        spam: false,
-        subject: null,
-        trashed: false,
-        unseenLocationCount: 0,
-    }),
-};
-const validPollShardCoordinatorRow = validRows.pollShardCoordinators;
-const pollShardCoordinatorSchema = Object.entries(appwrite.rowSchemas).find(([table]) => table === 'pollShardCoordinators')?.[1];
-describe('appwrite', () => {
-    it('publishes the production browser and OAuth configuration', () => {
-        expect(appwrite.environments).toEqual(['development', 'production', 'staging']);
-        expect(appwrite.deployments).toEqual({
-            development: {
-                applicationUrl: 'https://app.staging.marcoapp.io',
-                endpoint: 'https://nyc.cloud.appwrite.io/v1',
-                oauthClientIds: {
-                    google: '338197922176-oml1o2iputhhu3vijgue9h8sbfq17qme.apps.googleusercontent.com',
-                    microsoft: 'd34106a5-5210-417e-bf38-6ddbe3aa91a7',
-                },
-                projectId: 'marco',
-            },
-            production: {
-                applicationUrl: 'https://app.marcoapp.io',
-                endpoint: 'https://platform.marcoapp.io/v1',
-                oauthClientIds: {
-                    google: '338197922176-oml1o2iputhhu3vijgue9h8sbfq17qme.apps.googleusercontent.com',
-                    microsoft: 'd34106a5-5210-417e-bf38-6ddbe3aa91a7',
-                },
-                projectId: 'marco',
-            },
-            staging: {
-                applicationUrl: 'https://app.staging.marcoapp.io',
-                endpoint: 'https://nyc.cloud.appwrite.io/v1',
-                oauthClientIds: {
-                    google: '338197922176-oml1o2iputhhu3vijgue9h8sbfq17qme.apps.googleusercontent.com',
-                    microsoft: 'd34106a5-5210-417e-bf38-6ddbe3aa91a7',
-                },
-                projectId: 'marco',
-            },
-        });
-        expect(appwrite.deployments.development).not.toBe(appwrite.deployments.staging);
-        expect(appwrite.deployments.development.oauthClientIds).not.toBe(appwrite.deployments.staging.oauthClientIds);
-        expect(appwrite.deployments.development.oauthClientIds).not.toBe(appwrite.deployments.production.oauthClientIds);
-        expect(appwrite.deployments.production.oauthClientIds).not.toBe(appwrite.deployments.staging.oauthClientIds);
-    });
-    it('exports the approved resource identifiers', () => {
-        expect(appwrite.ids).toEqual({
-            bucket: 'marco-files',
-            database: 'marco',
-            functions: { api: 'marco-api', worker: 'marco-worker' },
-            tables: {
-                accounts: 'accounts',
-                aliases: 'aliases',
-                commands: 'commands',
-                contacts: 'contacts',
-                credentials: 'credentials',
-                drafts: 'drafts',
-                jobs: 'jobs',
-                labels: 'labels',
-                mailboxSyncCandidates: 'mailbox_sync_candidates',
-                mailboxSyncLanes: 'mailbox_sync_lanes',
-                mailboxSyncStates: 'mailbox_sync_states',
-                messageLocations: 'message_locations',
-                messages: 'messages',
-                oauthStates: 'oauth_states',
-                pollShardCoordinators: 'poll_shard_coordinators',
-                pollShards: 'poll_shards',
-                profileAvatarCleanups: 'profile_avatar_cleanups',
-                profiles: 'profiles',
-                pushNotificationTokens: 'push_notification_tokens',
-                savedViews: 'saved_views',
-                threadAliases: 'thread_aliases',
-                threadLabels: 'thread_labels',
-                threads: 'threads',
-            },
-        });
-    });
-    it('generates every table definition and schema from the shared contract', () => {
-        expect(Object.keys(appwrite.tables).sort()).toEqual(Object.keys(appwrite.ids.tables).sort());
-        const tableKeys = Object.keys(appwrite.ids.tables);
-        for (const tableKey of tableKeys) {
-            const tableId = appwrite.ids.tables[tableKey];
-            const table = appwrite.tables[tableKey];
-            const dataSchema = appwrite.dataSchemas[tableKey];
-            const rowSchema = appwrite.rowSchemas[tableKey];
-            const dataKeys = Object.keys(dataSchema.entries);
-            expect(table.id).toBe(tableId);
-            expect(Object.keys(rowSchema.entries)).toEqual(['$createdAt', '$databaseId', '$id', '$permissions', '$sequence', '$tableId', '$updatedAt', ...dataKeys]);
-            expect(dataKeys.sort()).toEqual([...table.columns.map(column => column.key), ...(table.relationships ?? []).map(relationship => relationship.key)].sort());
-        }
-    });
-    it('publishes every physical table ID exactly once', () => {
-        expect([...appwriteTableIds]).toEqual(Object.values(appwrite.ids.tables));
-        expect(new Set(appwriteTableIds).size).toBe(appwriteTableIds.length);
-    });
-    it('publishes the explicit physical message-location contract', () => {
-        expect(appwrite.tables.messageLocations.columns).toEqual([
-            { key: 'accountAssignmentKey', required: true, size: 36, type: 'string' },
-            { key: 'flagged', required: true, type: 'boolean' },
-            { key: 'labelAssignmentKey', required: true, size: 36, type: 'string' },
-            { key: 'messageAt', required: true, type: 'datetime' },
-            { key: 'seen', required: true, type: 'boolean' },
-            { key: 'threadAssignmentKey', required: true, size: 36, type: 'string' },
-            { key: 'uid', required: false, type: 'bigint' },
-            { key: 'uidValidity', required: false, type: 'bigint' },
-        ]);
-        expect(appwrite.tables.messageLocations.relationships).toEqual([
-            { key: 'account', onDelete: 'cascade', relatedTableId: appwrite.ids.tables.accounts, type: 'manyToOne' },
-            { key: 'label', onDelete: 'cascade', relatedTableId: appwrite.ids.tables.labels, type: 'manyToOne' },
-            { key: 'message', onDelete: 'cascade', relatedTableId: appwrite.ids.tables.messages, type: 'manyToOne' },
-            { key: 'thread', onDelete: 'cascade', relatedTableId: appwrite.ids.tables.threads, type: 'manyToOne' },
-        ]);
-    });
-    it('enforces nullable positive message-location coordinates as a pair', () => {
-        const messageLocations = appwrite.dataSchemas.messageLocations;
-        for (const coordinates of [
-            { uid: null, uidValidity: null },
-            { uid: 1, uidValidity: 1 },
-        ]) {
-            expect(v.safeParse(messageLocations, { ...validRows.messageLocations, ...coordinates }).success).toBe(true);
-        }
-        for (const coordinates of [
-            { uid: null, uidValidity: 1 },
-            { uid: 1, uidValidity: null },
-            { uid: 0, uidValidity: 1 },
-            { uid: 1, uidValidity: 0 },
-        ]) {
-            expect(v.safeParse(messageLocations, { ...validRows.messageLocations, ...coordinates }).success).toBe(false);
-        }
-    });
-    it('rejects zero mailbox-sync candidate coordinates', () => {
-        expect(v.safeParse(appwrite.dataSchemas.mailboxSyncCandidates.entries.uid, 0).success).toBe(false);
-        expect(v.safeParse(appwrite.dataSchemas.mailboxSyncCandidates.entries.uidValidity, 0).success).toBe(false);
-    });
-    it('rejects non-canonical persisted scheduling and lease fences', () => {
-        const fenceSchemas = [
-            appwrite.dataSchemas.credentials.entries.refreshLeaseExpiresAt,
-            appwrite.dataSchemas.drafts.entries.scheduledAt,
-            appwrite.dataSchemas.drafts.entries.executionLeaseExpiresAt,
-            appwrite.dataSchemas.mailboxSyncStates.entries.nextPollAt,
-            appwrite.dataSchemas.mailboxSyncStates.entries.materialisationLeaseExpiresAt,
-            appwrite.dataSchemas.jobs.entries.nextRunAt,
-            appwrite.dataSchemas.jobs.entries.leaseExpiresAt,
-            appwrite.dataSchemas.pollShards.entries.nextStartAt,
-            appwrite.dataSchemas.pollShards.entries.leaseExpiresAt,
-            appwrite.dataSchemas.threads.entries.snoozedUntil,
-        ];
-        for (const schema of fenceSchemas) {
-            expect(v.safeParse(schema, '2026-06-31T12:00:30.000Z').success).toBe(false);
-            expect(v.safeParse(schema, '2026-07-23T12:00:30.000+00:00').success).toBe(false);
-        }
-    });
-    it('pins every generated wire row to its table ID', () => {
-        const tableKeys = Object.keys(appwrite.ids.tables);
-        for (const tableKey of tableKeys) {
-            const wrongTableId = tableKey === 'accounts' ? appwrite.ids.tables.aliases : appwrite.ids.tables.accounts;
-            const rowSchema = appwrite.rowSchemas[tableKey];
-            const row = validRows[tableKey];
-            expect(v.safeParse(rowSchema, row).success).toBe(true);
-            expect(v.safeParse(rowSchema, { ...row, $tableId: wrongTableId }).success).toBe(false);
-        }
-    });
-    it('exports the shared OAuth state contract', () => {
-        expect(appwrite.oauth).toMatchObject({
-            operations: ['CONNECT', 'REPLACE'],
-            providers: ['GMAIL', 'OUTLOOK'],
-            returnUris: ['https://app.marcoapp.io/onboarding/loading'],
-        });
-    });
-    for (const operation of ['CONNECT', 'REPLACE']) {
-        it(`accepts a persisted ${operation} OAuth state completing at production loading`, () => {
-            expect(v.safeParse(appwrite.rowSchemas.oauthStates, { ...validRows.oauthStates, operation }).success).toBe(true);
-        });
-    }
-    for (const returnUri of [
-        'https://app.marcoapp.io/onboarding/provider-selection',
-        'https://app.staging.marcoapp.io/onboarding/loading',
-        'https://attacker.example/onboarding/loading',
-        'https://app.marcoapp.io/onboarding/loading/unexpected',
-    ]) {
-        it(`rejects persisted OAuth state with unapproved return URI ${returnUri}`, () => {
-            expect(v.safeParse(appwrite.rowSchemas.oauthStates, { ...validRows.oauthStates, returnUri }).success).toBe(false);
-        });
-    }
-    it('exports the final polling-only mailbox contract', () => {
-        expect(appwrite.mailboxSync).toEqual({
-            lanes: ['HEAD', 'BACKFILL'],
-            laneStates: ['PENDING', 'RUNNING', 'COMPLETED', 'FAILED'],
-            states: ['INITIAL', 'SYNCING', 'CURRENT', 'ERROR'],
-        });
-        expect(appwrite.polling).toEqual({ shardStates: ['ACTIVE', 'STOPPED', 'FAILED'] });
-    });
-    it('accepts CURRENT and rejects the retired IDLE mailbox sync state', () => {
-        expect(v.safeParse(appwrite.rowSchemas.mailboxSyncStates, { ...validRows.mailboxSyncStates, state: 'CURRENT' }).success).toBe(true);
-        expect(v.safeParse(appwrite.rowSchemas.mailboxSyncStates, { ...validRows.mailboxSyncStates, state: 'IDLE' }).success).toBe(false);
-    });
-    it('keys saved views by stable alias IDs', () => {
-        expect(v.safeParse(appwrite.rowSchemas.savedViews, validRows.savedViews).success).toBe(true);
-        expect(v.safeParse(appwrite.rowSchemas.savedViews, { ...validRows.savedViews, aliasEmails: ['marco@example.com'] }).success).toBe(false);
-    });
-    it('rejects a mailbox sync lane without a command identifier', () => {
-        expect(v.safeParse(appwrite.rowSchemas.mailboxSyncLanes, {
-            ...validRows.mailboxSyncLanes,
-            commandId: '',
-        }).success).toBe(false);
-    });
-    it('rejects a poll shard with more than ten accounts', () => {
-        expect(v.safeParse(appwrite.rowSchemas.pollShards, {
-            ...validRows.pollShards,
-            accountIds: Array.from({ length: 11 }, (_, index) => `test-account-id-${index + 1}`),
-        }).success).toBe(false);
-    });
-    it('accepts a populated poll shard snapshot', () => {
-        expect(v.safeParse(appwrite.rowSchemas.pollShards, {
-            ...validRows.pollShards,
-            pollingSnapshot: '{"members":[]}',
-        }).success).toBe(true);
-    });
-    it('exports the strict server-only poll shard coordinator row contract', () => {
-        expect(pollShardCoordinatorSchema).toBeDefined();
-        if (pollShardCoordinatorSchema) {
-            for (const accountCursor of [null, 'test-account-id-1']) {
-                expect(v.safeParse(pollShardCoordinatorSchema, { ...validPollShardCoordinatorRow, accountCursor }).success).toBe(true);
-            }
-            expect(v.safeParse(pollShardCoordinatorSchema, { ...validPollShardCoordinatorRow, $permissions: ['read("user:test-user-id-1")'] }).success).toBe(false);
-            expect(v.safeParse(pollShardCoordinatorSchema, { ...validPollShardCoordinatorRow, unexpected: true }).success).toBe(false);
-            const { $id: _, ...rowWithoutId } = validPollShardCoordinatorRow;
-            expect(v.safeParse(pollShardCoordinatorSchema, rowWithoutId).success).toBe(false);
-        }
-    });
-    const serverOnlyPollingRows = [
-        { row: validRows.mailboxSyncLanes, schema: appwrite.rowSchemas.mailboxSyncLanes },
-        { row: validRows.pollShards, schema: appwrite.rowSchemas.pollShards },
-    ];
-    for (const { row, schema } of serverOnlyPollingRows) {
-        it(`rejects client permissions on ${row.$tableId}`, () => {
-            expect(v.safeParse(schema, { ...row, $permissions: ['read("user:test-user-id-1")'] }).success).toBe(false);
-        });
-    }
-    const rowTestCases = Object.keys(validRows);
-    for (const table of rowTestCases) {
-        it(`accepts the ${table} wire row`, () => {
-            expect(v.safeParse(appwrite.rowSchemas[table], validRows[table]).success).toBe(true);
-        });
-        it(`rejects incomplete ${table} metadata`, () => {
-            const { $id: _, ...rowWithoutId } = validRows[table];
-            expect(v.safeParse(appwrite.rowSchemas[table], rowWithoutId).success).toBe(false);
-        });
-    }
-    it('normalises Appwrite relationship objects to row IDs', () => {
-        const account = v.parse(appwrite.rowSchemas.accounts, {
-            ...validRows.accounts,
-            credential: { $id: 'credential-1' },
-            mailboxSyncState: { $id: 'mailbox-sync-state-1' },
-            primaryAlias: { $id: 'alias-1' },
-            profile: { $id: 'user-1' },
-        });
-        const alias = v.parse(appwrite.rowSchemas.aliases, { ...validRows.aliases, account: { $id: 'account-1' } });
-        const command = v.parse(appwrite.rowSchemas.commands, { ...validRows.commands, account: { $id: 'account-1' }, profile: { $id: 'user-1' } });
-        const contact = v.parse(appwrite.rowSchemas.contacts, { ...validRows.contacts, profile: { $id: 'user-1' } });
-        const draft = v.parse(appwrite.rowSchemas.drafts, {
-            ...validRows.drafts,
-            account: { $id: 'account-1' },
-            fromAlias: { $id: 'alias-1' },
-            referencedMessage: { $id: 'message-1' },
-        });
-        const label = v.parse(appwrite.rowSchemas.labels, { ...validRows.labels, account: { $id: 'account-1' } });
-        const mailboxSyncCandidate = v.parse(appwrite.rowSchemas.mailboxSyncCandidates, {
-            ...validRows.mailboxSyncCandidates,
-            account: { $id: 'account-1' },
-            label: { $id: 'label-1' },
-        });
-        const mailboxSyncLane = v.parse(appwrite.rowSchemas.mailboxSyncLanes, { ...validRows.mailboxSyncLanes, account: { $id: 'account-1' } });
-        const messageLocation = v.parse(appwrite.rowSchemas.messageLocations, {
-            ...validRows.messageLocations,
-            account: { $id: 'account-1' },
-            label: { $id: 'label-1' },
-            message: { $id: 'message-1' },
-            thread: { $id: 'thread-1' },
-        });
-        const oauthState = v.parse(appwrite.rowSchemas.oauthStates, { ...validRows.oauthStates, profile: { $id: 'user-1' } });
-        const profileAvatarCleanup = v.parse(appwrite.rowSchemas.profileAvatarCleanups, { ...validRows.profileAvatarCleanups, profile: { $id: 'user-1' } });
-        const pushNotificationToken = v.parse(appwrite.rowSchemas.pushNotificationTokens, { ...validRows.pushNotificationTokens, profile: { $id: 'user-1' } });
-        const savedView = v.parse(appwrite.rowSchemas.savedViews, { ...validRows.savedViews, profile: { $id: 'user-1' } });
-        expect(account.credential).toBe('credential-1');
-        expect(account.mailboxSyncState).toBe('mailbox-sync-state-1');
-        expect(account.primaryAlias).toBe('alias-1');
-        expect(account.profile).toBe('user-1');
-        expect(alias.account).toBe('account-1');
-        expect(command.account).toBe('account-1');
-        expect(command.profile).toBe('user-1');
-        expect(contact.profile).toBe('user-1');
-        expect(draft.account).toBe('account-1');
-        expect(draft.fromAlias).toBe('alias-1');
-        expect(draft.referencedMessage).toBe('message-1');
-        expect(label.account).toBe('account-1');
-        expect(mailboxSyncCandidate.account).toBe('account-1');
-        expect(mailboxSyncCandidate.label).toBe('label-1');
-        expect(mailboxSyncLane.account).toBe('account-1');
-        expect(messageLocation.account).toBe('account-1');
-        expect(messageLocation.label).toBe('label-1');
-        expect(messageLocation.message).toBe('message-1');
-        expect(messageLocation.thread).toBe('thread-1');
-        expect(oauthState.profile).toBe('user-1');
-        expect(profileAvatarCleanup.profile).toBe('user-1');
-        expect(pushNotificationToken.profile).toBe('user-1');
-        expect(savedView.profile).toBe('user-1');
-    });
-    it('accepts backend message sender fields as plain nullable text', () => {
-        expect(v.safeParse(appwrite.rowSchemas.messages, {
-            ...validRows.messages,
-            sender: 'not-an-email',
-            senderName: '',
-        }).success).toBe(true);
-    });
-    const requiredMailboxReferenceFieldTestCases = [
-        { field: 'account', row: { ...validRows.messages, account: null }, schema: appwrite.rowSchemas.messages, table: 'messages' },
-        { field: 'thread', row: { ...validRows.messages, thread: null }, schema: appwrite.rowSchemas.messages, table: 'messages' },
-        { field: 'account', row: { ...validRows.threads, account: null }, schema: appwrite.rowSchemas.threads, table: 'threads' },
-        { field: 'alias', row: { ...validRows.threadAliases, alias: null }, schema: appwrite.rowSchemas.threadAliases, table: 'threadAliases' },
-        { field: 'thread', row: { ...validRows.threadAliases, thread: null }, schema: appwrite.rowSchemas.threadAliases, table: 'threadAliases' },
-        { field: 'label', row: { ...validRows.threadLabels, label: null }, schema: appwrite.rowSchemas.threadLabels, table: 'threadLabels' },
-        { field: 'thread', row: { ...validRows.threadLabels, thread: null }, schema: appwrite.rowSchemas.threadLabels, table: 'threadLabels' },
-    ];
-    for (const { field, row, schema, table } of requiredMailboxReferenceFieldTestCases) {
-        it(`rejects nullable ${field} references on ${table}`, () => {
-            expect(v.safeParse(schema, row).success).toBe(false);
-        });
-    }
-    const nullableColumnTestCases = [
-        {
-            description: 'alias name',
-            row: { ...validRows.aliases, name: null },
-            schema: appwrite.rowSchemas.aliases,
-        },
-        {
-            description: 'alias signature',
-            row: { ...validRows.aliases, signature: null },
-            schema: appwrite.rowSchemas.aliases,
-        },
-        {
-            description: 'contact display name',
-            row: { ...validRows.contacts, displayName: null },
-            schema: appwrite.rowSchemas.contacts,
-        },
-        {
-            description: 'contact last-contacted timestamp',
-            row: { ...validRows.contacts, lastContactedAt: null },
-            schema: appwrite.rowSchemas.contacts,
-        },
-        {
-            description: 'saved-view icon',
-            row: { ...validRows.savedViews, icon: null },
-            schema: appwrite.rowSchemas.savedViews,
-        },
-        {
-            description: 'thread first-message timestamp',
-            row: { ...validRows.threads, firstMessageAt: null },
-            schema: appwrite.rowSchemas.threads,
-        },
-        {
-            description: 'thread sender email',
-            row: { ...validRows.threads, senderEmail: null },
-            schema: appwrite.rowSchemas.threads,
-        },
-        {
-            description: 'thread sender name',
-            row: { ...validRows.threads, senderName: null },
-            schema: appwrite.rowSchemas.threads,
-        },
-    ];
-    for (const { description, row, schema } of nullableColumnTestCases) {
-        it(`accepts a wire row with a nullable ${description}`, () => {
-            expect(v.safeParse(schema, row).success).toBe(true);
-        });
-    }
-    it('accepts provider-derived RFC email addresses', () => {
-        const maximumLengthMailboxAddress = `${'a'.repeat(64)}@${'b'.repeat(63)}.${'c'.repeat(63)}.${'d'.repeat(63)}.${'e'.repeat(63)}`;
-        const mailboxAddresses = ['sender@example', 'first.last+tag@example.com', maximumLengthMailboxAddress];
-        expect(maximumLengthMailboxAddress).toHaveLength(320);
-        for (const mailboxAddress of mailboxAddresses) {
-            expect(v.safeParse(appwrite.rowSchemas.contacts, { ...validRows.contacts, normalisedAddress: mailboxAddress }).success).toBe(true);
-            expect(v.safeParse(appwrite.rowSchemas.threads, { ...validRows.threads, senderEmail: mailboxAddress }).success).toBe(true);
-            expect(v.safeParse(appwrite.decodedSchemas.draftEnvelope, JSON.stringify({ bcc: [mailboxAddress], cc: [mailboxAddress], subject: null, to: [mailboxAddress] })).success).toBe(true);
-            expect(v.safeParse(appwrite.decodedSchemas.messageRecipients, JSON.stringify([{ emailAddress: mailboxAddress, name: null, type: 'to' }])).success).toBe(true);
-        }
-        expect(v.safeParse(appwrite.rowSchemas.contacts, { ...validRows.contacts, normalisedAddress: '' }).success).toBe(false);
-        expect(v.safeParse(appwrite.rowSchemas.contacts, { ...validRows.contacts, normalisedAddress: 'invalid@@example.com' }).success).toBe(false);
-        expect(v.safeParse(appwrite.rowSchemas.contacts, { ...validRows.contacts, normalisedAddress: 'a'.repeat(321) }).success).toBe(false);
-    });
-    it('keeps account identity emails on the strict web-email boundary', () => {
-        expect(v.safeParse(appwrite.rowSchemas.accounts, { ...validRows.accounts, primaryEmail: 'sender@example' }).success).toBe(false);
-        expect(v.safeParse(appwrite.rowSchemas.aliases, { ...validRows.aliases, email: '"a@b"@example.com' }).success).toBe(false);
-    });
-    const { name: _aliasName, ...aliasWithoutName } = validRows.aliases;
-    const { signature: _aliasSignature, ...aliasWithoutSignature } = validRows.aliases;
-    const { displayName: _contactDisplayName, ...contactWithoutDisplayName } = validRows.contacts;
-    const { lastContactedAt: _contactLastContactedAt, ...contactWithoutLastContactedAt } = validRows.contacts;
-    const { icon: _savedViewIcon, ...savedViewWithoutIcon } = validRows.savedViews;
-    const { firstMessageAt: _threadFirstMessageAt, ...threadWithoutFirstMessageAt } = validRows.threads;
-    const { senderEmail: _threadSenderEmail, ...threadWithoutSenderEmail } = validRows.threads;
-    const { senderName: _threadSenderName, ...threadWithoutSenderName } = validRows.threads;
-    const missingNullableColumnTestCases = [
-        {
-            description: 'alias name',
-            row: aliasWithoutName,
-            schema: appwrite.rowSchemas.aliases,
-        },
-        {
-            description: 'alias signature',
-            row: aliasWithoutSignature,
-            schema: appwrite.rowSchemas.aliases,
-        },
-        {
-            description: 'contact display name',
-            row: contactWithoutDisplayName,
-            schema: appwrite.rowSchemas.contacts,
-        },
-        {
-            description: 'contact last-contacted timestamp',
-            row: contactWithoutLastContactedAt,
-            schema: appwrite.rowSchemas.contacts,
-        },
-        {
-            description: 'saved-view icon',
-            row: savedViewWithoutIcon,
-            schema: appwrite.rowSchemas.savedViews,
-        },
-        {
-            description: 'thread first-message timestamp',
-            row: threadWithoutFirstMessageAt,
-            schema: appwrite.rowSchemas.threads,
-        },
-        {
-            description: 'thread sender email',
-            row: threadWithoutSenderEmail,
-            schema: appwrite.rowSchemas.threads,
-        },
-        {
-            description: 'thread sender name',
-            row: threadWithoutSenderName,
-            schema: appwrite.rowSchemas.threads,
-        },
-    ];
-    for (const { description, row, schema } of missingNullableColumnTestCases) {
-        it(`rejects a wire row missing its nullable ${description}`, () => {
-            expect(v.safeParse(schema, row).success).toBe(false);
-        });
-    }
-    const validOAuthStates = [
-        { expected: true, operation: 'CONNECT', provider: 'GMAIL' },
-        { expected: true, operation: 'REPLACE', provider: 'OUTLOOK' },
-    ];
-    for (const { expected, operation, provider } of validOAuthStates) {
-        it(`accepts the ${operation} ${provider} OAuth state`, () => {
-            expect(v.safeParse(appwrite.rowSchemas.oauthStates, {
-                ...validRows.oauthStates,
-                operation,
-                provider,
-            }).success).toBe(expected);
-        });
-    }
-    const invalidOAuthStates = [
-        { description: 'an unknown operation', expected: false, value: { operation: 'UNKNOWN' } },
-        { description: 'an unknown provider', expected: false, value: { provider: 'UNKNOWN' } },
-        { description: 'a malformed return URL', expected: false, value: { returnUri: 'not-a-url' } },
-        {
-            description: 'an unapproved return destination',
-            expected: false,
-            value: { returnUri: 'https://attacker.example/onboarding/provider-selection' },
-        },
-    ];
-    for (const { description, expected, value } of invalidOAuthStates) {
-        it(`rejects an OAuth state with ${description}`, () => {
-            expect(v.safeParse(appwrite.rowSchemas.oauthStates, { ...validRows.oauthStates, ...value }).success).toBe(expected);
-        });
-    }
-    const invalidSequences = [
-        { description: 'numeric', value: 1 },
-        { description: 'empty', value: '' },
-    ];
-    for (const { description, value } of invalidSequences) {
-        it(`rejects ${description} Appwrite sequence metadata`, () => {
-            expect(v.safeParse(appwrite.rowSchemas.profiles, { ...validRows.profiles, $sequence: value }).success).toBe(false);
-        });
-    }
-    it('accepts a provider-canonical label name', () => {
-        expect(v.safeParse(appwrite.rowSchemas.labels, { ...validRows.labels, name: 'CATEGORY_PROMOTIONS' }).success).toBe(true);
-    });
-    it('accepts nullable thread text before body materialisation', () => {
-        expect(v.safeParse(appwrite.rowSchemas.threads, {
-            ...validRows.threads,
-            participants: null,
-            preview: null,
-            searchText: null,
-        }).success).toBe(true);
-    });
-    const invalidAccountRows = [
-        { description: 'an unknown state', row: { ...validRows.accounts, state: 'UNKNOWN' } },
-        { description: 'an unknown database ID', row: { ...validRows.accounts, $databaseId: 'other' } },
-        { description: 'a leading separator in $id', row: { ...validRows.accounts, $id: '-row-1' } },
-        { description: 'an overlong $id', row: { ...validRows.accounts, $id: 'a'.repeat(37) } },
-    ];
-    for (const testCase of invalidAccountRows) {
-        it(`rejects ${testCase.description}`, () => {
-            expect(v.safeParse(appwrite.rowSchemas.accounts, testCase.row).success).toBe(false);
-        });
-    }
-    const jsonTextTestCases = [
-        {
-            expected: [
-                {
-                    fileId: 'test-file-id-1',
-                    isAttachment: true,
-                    mimeType: 'text/plain',
-                    name: 'test-file-name-1.txt',
-                    partNumber: '2',
-                    size: 1,
-                },
-            ],
-            invalidValue: '[{"fileId":"test-file-id-1"}]',
-            name: 'message attachments',
-            schema: appwrite.decodedSchemas.messageAttachments,
-            value: '[{"fileId":"test-file-id-1","isAttachment":true,"mimeType":"text/plain","name":"test-file-name-1.txt","partNumber":"2","size":1}]',
-        },
-        {
-            expected: [
-                {
-                    fileId: 'test-file-id-1',
-                    fileName: 'test-file-name-1.txt',
-                    mimeType: 'text/plain',
-                    size: 1,
-                },
-            ],
-            invalidValue: '[{"fileId":"test-file-id-1"}]',
-            name: 'draft attachments',
-            schema: appwrite.decodedSchemas.draftAttachments,
-            value: '[{"fileId":"test-file-id-1","fileName":"test-file-name-1.txt","mimeType":"text/plain","size":1}]',
-        },
-        {
-            expected: { threadId: 'thread-1' },
-            invalidValue: '[]',
-            name: 'command payload',
-            schema: appwrite.decodedSchemas.commandPayload,
-            value: '{"threadId":"thread-1"}',
-        },
-        {
-            expected: { bcc: [], cc: [], subject: null, to: [] },
-            invalidValue: '[]',
-            name: 'draft envelope',
-            schema: appwrite.decodedSchemas.draftEnvelope,
-            value: '{"bcc":[],"cc":[],"subject":null,"to":[]}',
-        },
-        {
-            expected: { threadId: 'thread-1' },
-            invalidValue: '[]',
-            name: 'job payload',
-            schema: appwrite.decodedSchemas.jobPayload,
-            value: '{"threadId":"thread-1"}',
-        },
-        {
-            expected: [
-                {
-                    emailAddress: 'recipient@example.com',
-                    name: 'Recipient',
-                    type: 'to',
-                },
-            ],
-            invalidValue: '[{"emailAddress":"recipient@example.com"}]',
-            name: 'message recipients',
-            schema: appwrite.decodedSchemas.messageRecipients,
-            value: '[{"emailAddress":"recipient@example.com","name":"Recipient","type":"to"}]',
-        },
-    ];
-    for (const testCase of jsonTextTestCases) {
-        it(`decodes ${testCase.name} JSON text`, () => {
-            const result = v.safeParse(testCase.schema, testCase.value);
-            expect(result.success).toBe(true);
-            if (result.success) {
-                const output = result.output;
-                expect(output).toEqual(testCase.expected);
-            }
-            expect(v.safeParse(testCase.schema, testCase.invalidValue).success).toBe(false);
-            expect(v.safeParse(testCase.schema, '{').success).toBe(false);
-        });
-    }
-    it('keeps persisted draft envelope constraints strict and bounded', () => {
-        const envelope = { bcc: ['sender@example'], cc: [], subject: 'a'.repeat(998), to: ['recipient@example.com'] };
-        expect(v.safeParse(appwrite.decodedSchemas.draftEnvelope, JSON.stringify(envelope)).success).toBe(true);
-        for (const invalidEnvelope of [
-            { ...envelope, subject: 'a'.repeat(999) },
-            { ...envelope, to: ['not-an-address'] },
-            { ...envelope, unexpected: true },
-        ]) {
-            expect(v.safeParse(appwrite.decodedSchemas.draftEnvelope, JSON.stringify(invalidEnvelope)).success).toBe(false);
-        }
-    });
-    it('keeps persisted draft attachment constraints strict and bounded', () => {
-        const attachment = { fileId: 'test-file-id-1', fileName: 'proposal.pdf', mimeType: 'application/pdf', size: 0 };
-        expect(v.safeParse(appwrite.decodedSchemas.draftAttachments, JSON.stringify([attachment])).success).toBe(true);
-        for (const invalidAttachment of [
-            { ...attachment, fileId: '-invalid' },
-            { ...attachment, fileName: 'a'.repeat(256) },
-            { ...attachment, mimeType: 'x' },
-            { ...attachment, size: -1 },
-            { ...attachment, unexpected: true },
-        ]) {
-            expect(v.safeParse(appwrite.decodedSchemas.draftAttachments, JSON.stringify([invalidAttachment])).success).toBe(false);
-        }
-    });
-});