@marcoappio/marco-config 4.0.26 → 6.0.0

package/dist/appwrite/functions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"functions.d.ts","sourceRoot":"","sources":["../../src/appwrite/functions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,6BAA6B,CAAA;AAU/C,KAAK,uBAAuB,GAAG,eAAe,GAAG,UAAU,GAAG,QAAQ,GAAG,SAAS,CAAA;AAgMlF,eAAO,MAAM,iBAAiB;aAC5B,GAAG;iBACD,EAAE;iBACF,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAER,UAAU;aACV,WAAW;;;;aACX,MAAM;iBACJ,EAAE;iBACF,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAEA,CAAA;AAEV,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,iBAAiB,CAAC,WAAW,CAAC,CAAA;AACvF,YAAY,EAAE,uBAAuB,EAAE,CAAA;AACvC,MAAM,MAAM,oBAAoB,GAAG,KAAK,GAAG,QAAQ,CAAA;AACnD,MAAM,MAAM,yBAAyB,CAAC,SAAS,SAAS,oBAAoB,IAAI,SAAS,SAAS,oBAAoB,GAClH,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC,SAAS,CAAC,CAAC,QAAQ,CAAC,GACrD,KAAK,CAAA;AACT,MAAM,MAAM,qBAAqB,CAAC,SAAS,SAAS,oBAAoB,EAAE,MAAM,SAAS,yBAAyB,CAAC,SAAS,CAAC,IAAI,SAAS,SAAS,oBAAoB,GACnK,MAAM,SAAS,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC,SAAS,CAAC,CAAC,QAAQ,CAAC,GAClE,CAAC,OAAO,iBAAiB,CAAC,CAAC,SAAS,CAAC,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,GACvD,KAAK,GACP,KAAK,CAAA;AACT,MAAM,MAAM,uBAAuB,CAAC,SAAS,SAAS,oBAAoB,EAAE,MAAM,SAAS,yBAAyB,CAAC,SAAS,CAAC,IAC7H,qBAAqB,CAAC,SAAS,EAAE,MAAM,CAAC,SAAS;IAAE,aAAa,EAAE,MAAM,OAAO,SAAS,CAAC,CAAC,aAAa,CAAA;CAAE,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,CAAC,GAAG,KAAK,CAAA;AAC5I,MAAM,MAAM,wBAAwB,CAAC,SAAS,SAAS,oBAAoB,EAAE,MAAM,SAAS,yBAAyB,CAAC,SAAS,CAAC,IAC9H,qBAAqB,CAAC,SAAS,EAAE,MAAM,CAAC,SAAS;IAAE,cAAc,EAAE,MAAM,OAAO,SAAS,CAAC,CAAC,aAAa,CAAA;CAAE,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,CAAC,GAAG,KAAK,CAAA"}

package/dist/appwrite/functions.js

@@ -1,192 +0,0 @@
-import { v } from '../utils/valibot/index.js';
-import { oauth } from '../constants/oauth.js';
-import { id } from '../schemas/id.js';
-import { string } from '../schemas/string.js';
-import { appwrite } from './appwrite.js';
-import { appwriteCommands } from './commands.js';
-import { accountStates, appwriteRowIdSchema, canonicalTimestampSchema, portSchema, socketTypes, webEmailSchema } from './tableContract/index.js';
-const functionErrorCodes = [
-    'AUTHENTICATION_FAILED',
-    'AUTHORIZATION_FAILED',
-    'CONFLICT',
-    'INVALID_REQUEST',
-    'NOT_FOUND',
-    'PROVIDER_REJECTED',
-    'TRANSIENT_FAILURE',
-    'INTERNAL_ERROR',
-];
-const functionErrorSchema = v.strictObject({
-    code: v.picklist(functionErrorCodes),
-    retryable: v.boolean(),
-});
-const providerCredentialSchema = v.strictObject({
-    host: string.required(4096),
-    password: string.required(4096),
-    port: portSchema,
-    socketType: v.picklist(socketTypes),
-    user: string.required(4096),
-});
-const connectionSchema = v.variant('kind', [
-    v.strictObject({
-        email: webEmailSchema,
-        kind: v.literal('OAUTH'),
-        provider: v.picklist(['GMAIL', 'OUTLOOK']),
-        returnUri: appwrite.oauth.returnUriSchema,
-    }),
-    v.strictObject({
-        imap: providerCredentialSchema,
-        kind: v.literal('IMAP'),
-        smtp: providerCredentialSchema,
-    }),
-]);
-const connectionResultSchema = v.strictObject({
-    accountId: id.accountId.required(),
-    authorizationUrl: v.optional(v.pipe(v.string(), v.url())),
-    state: v.picklist(accountStates),
-});
-const completedSchema = v.strictObject({ state: v.literal('COMPLETED') });
-const emptySchema = v.strictObject({});
-const authUserIdSchema = appwriteRowIdSchema;
-const authSendCodeRequestSchema = v.strictObject({
-    email: string.email(),
-    userId: authUserIdSchema,
-});
-const authSendCodeResponseSchema = v.strictObject({ userId: authUserIdSchema });
-const authVerifyCodeRequestSchema = v.strictObject({
-    code: v.pipe(v.string(), v.regex(/^\d{6}$/)),
-    email: string.email(),
-    userId: authUserIdSchema,
-});
-const authVerifyCodeResponseSchema = v.strictObject({
-    secret: string.required(4096),
-    userId: authUserIdSchema,
-});
-const createRoute = (route) => ({
-    ...route,
-    errorSchema: functionErrorSchema,
-});
-const apiRoutes = {
-    accountConnection: createRoute({
-        context: 'authenticated',
-        method: 'PUT',
-        path: '/accounts/connection',
-        requestSchema: v.strictObject({
-            accountId: id.accountId.required(),
-            connection: connectionSchema,
-        }),
-        responseSchema: connectionResultSchema,
-    }),
-    accountDelete: createRoute({
-        context: 'authenticated',
-        method: 'DELETE',
-        path: '/account/delete',
-        requestSchema: emptySchema,
-        responseSchema: v.strictObject({ state: v.literal('ACCEPTED') }),
-    }),
-    accountsConnect: createRoute({
-        context: 'authenticated',
-        method: 'POST',
-        path: '/accounts/connect',
-        requestSchema: v.strictObject({ connection: connectionSchema }),
-        responseSchema: connectionResultSchema,
-    }),
-    accountsPoll: createRoute({
-        context: 'authenticated',
-        method: 'POST',
-        path: '/accounts/poll',
-        requestSchema: emptySchema,
-        responseSchema: v.strictObject({
-            commands: v.array(v.strictObject({
-                accountId: id.accountId.required(),
-                commandId: appwriteRowIdSchema,
-            })),
-            failedAccountIds: v.array(id.accountId.required()),
-        }),
-    }),
-    authSendCode: createRoute({
-        context: 'public',
-        method: 'POST',
-        path: '/auth/send-code',
-        requestSchema: authSendCodeRequestSchema,
-        responseSchema: authSendCodeResponseSchema,
-    }),
-    authVerifyCode: createRoute({
-        context: 'public',
-        method: 'POST',
-        path: '/auth/verify-code',
-        requestSchema: authVerifyCodeRequestSchema,
-        responseSchema: authVerifyCodeResponseSchema,
-    }),
-    commands: createRoute({
-        context: 'authenticated',
-        method: 'POST',
-        path: '/commands',
-        requestSchema: appwriteCommands.requestSchema,
-        responseSchema: appwriteCommands.responseSchema,
-    }),
-    oauthWebhook: createRoute({
-        context: 'webhook',
-        method: 'GET',
-        path: oauth.redirectPath,
-        requestSchema: v.object({
-            code: string.required(4096),
-            state: string.required(4096),
-        }),
-        responseSchema: completedSchema,
-    }),
-    pollsRun: createRoute({
-        context: 'internal',
-        method: 'POST',
-        path: '/polls/run',
-        requestSchema: v.strictObject({
-            scheduledFor: canonicalTimestampSchema,
-            shardId: appwriteRowIdSchema,
-        }),
-        responseSchema: completedSchema,
-    }),
-    profileEnsure: createRoute({
-        context: 'authenticated',
-        method: 'POST',
-        path: '/profile/ensure',
-        requestSchema: emptySchema,
-        responseSchema: v.strictObject({ created: v.boolean() }),
-    }),
-    pushTokens: createRoute({
-        context: 'authenticated',
-        method: 'POST',
-        path: '/push-tokens',
-        requestSchema: v.strictObject({
-            operation: v.picklist(['REGISTER', 'REMOVE']),
-            token: string.required(4096),
-        }),
-        responseSchema: v.strictObject({ registered: v.boolean() }),
-    }),
-};
-const workerRoutes = {
-    jobsRun: createRoute({
-        context: 'internal',
-        method: 'POST',
-        path: '/jobs/run',
-        requestSchema: v.strictObject({ jobId: id.jobId.required() }),
-        responseSchema: completedSchema,
-    }),
-    supervisor: createRoute({
-        context: 'internal',
-        method: 'POST',
-        path: '/',
-        requestSchema: emptySchema,
-        responseSchema: completedSchema,
-    }),
-};
-export const appwriteFunctions = {
-    api: {
-        id: appwrite.ids.functions.api,
-        routes: apiRoutes,
-    },
-    errorCodes: functionErrorCodes,
-    errorSchema: functionErrorSchema,
-    worker: {
-        id: appwrite.ids.functions.worker,
-        routes: workerRoutes,
-    },
-};

package/dist/appwrite/functions.test.d.ts

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

package/dist/appwrite/functions.test.d.ts.map

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

package/dist/appwrite/functions.test.js

@@ -1,370 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import { v } from '../utils/valibot/index.js';
-import { appwriteFunctions } from './functions.js';
-const command = {
-    accountId: null,
-    id: '0197f3d4-1b22-7abc-8def-123456789abc',
-    kind: 'profile.settings.set',
-    payload: { name: 'Isaac' },
-    submittedAt: '2026-07-15T00:00:00.000Z',
-    version: 1,
-};
-const routeFixtures = [
-    {
-        name: 'profile ensure',
-        request: {},
-        response: { created: true },
-        route: () => appwriteFunctions.api.routes.profileEnsure,
-    },
-    {
-        name: 'commands',
-        request: command,
-        response: { canonicalRevision: null, error: null, id: command.id, state: 'ACCEPTED' },
-        route: () => appwriteFunctions.api.routes.commands,
-    },
-    {
-        name: 'account connection',
-        request: {
-            accountId: 'account_1',
-            connection: {
-                imap: {
-                    host: 'imap.example.com',
-                    password: 'password',
-                    port: 993,
-                    socketType: 'SSL',
-                    user: 'marco@example.com',
-                },
-                kind: 'IMAP',
-                smtp: {
-                    host: 'smtp.example.com',
-                    password: 'password',
-                    port: 465,
-                    socketType: 'SSL',
-                    user: 'marco@example.com',
-                },
-            },
-        },
-        response: { accountId: 'account_1', state: 'CONNECTED' },
-        route: () => appwriteFunctions.api.routes.accountConnection,
-    },
-    {
-        name: 'account connect',
-        request: {
-            connection: {
-                email: 'test-user@example.com',
-                kind: 'OAUTH',
-                provider: 'GMAIL',
-                returnUri: 'https://app.marcoapp.io/onboarding/loading',
-            },
-        },
-        response: {
-            accountId: 'account_1',
-            authorizationUrl: 'https://accounts.google.com/o/oauth2/auth',
-            state: 'AWAITING_CONNECTION',
-        },
-        route: () => appwriteFunctions.api.routes.accountsConnect,
-    },
-    {
-        name: 'account poll',
-        request: {},
-        response: {
-            commands: [{ accountId: 'test-account-id-1', commandId: 'sync_0123456789abcdef0123456789ab' }],
-            failedAccountIds: ['test-account-id-2'],
-        },
-        route: () => appwriteFunctions.api.routes.accountsPoll,
-    },
-    {
-        name: 'push tokens',
-        request: { operation: 'REGISTER', token: 'ExponentPushToken[example]' },
-        response: { registered: true },
-        route: () => appwriteFunctions.api.routes.pushTokens,
-    },
-    {
-        name: 'account deletion',
-        request: {},
-        response: { state: 'ACCEPTED' },
-        route: () => appwriteFunctions.api.routes.accountDelete,
-    },
-    {
-        name: 'OAuth webhook',
-        request: { code: 'authorisation-code', state: 'state' },
-        response: { state: 'COMPLETED' },
-        route: () => appwriteFunctions.api.routes.oauthWebhook,
-    },
-    {
-        name: 'worker supervisor',
-        request: {},
-        response: { state: 'COMPLETED' },
-        route: () => appwriteFunctions.worker.routes.supervisor,
-    },
-    {
-        name: 'job runner',
-        request: { jobId: 'job_1' },
-        response: { state: 'COMPLETED' },
-        route: () => appwriteFunctions.worker.routes.jobsRun,
-    },
-    {
-        name: 'poll runner',
-        request: { scheduledFor: '2026-07-23T12:00:30.000Z', shardId: 'test-poll-shard-id-1' },
-        response: { state: 'COMPLETED' },
-        route: () => appwriteFunctions.api.routes.pollsRun,
-    },
-];
-describe('appwriteFunctions', () => {
-    it('publishes the complete Appwrite Function route manifest', () => {
-        expect([
-            { functionId: appwriteFunctions.api.id, route: appwriteFunctions.api.routes.profileEnsure },
-            { functionId: appwriteFunctions.api.id, route: appwriteFunctions.api.routes.authSendCode },
-            { functionId: appwriteFunctions.api.id, route: appwriteFunctions.api.routes.authVerifyCode },
-            { functionId: appwriteFunctions.api.id, route: appwriteFunctions.api.routes.commands },
-            { functionId: appwriteFunctions.api.id, route: appwriteFunctions.api.routes.accountsConnect },
-            { functionId: appwriteFunctions.api.id, route: appwriteFunctions.api.routes.accountsPoll },
-            { functionId: appwriteFunctions.api.id, route: appwriteFunctions.api.routes.accountConnection },
-            { functionId: appwriteFunctions.api.id, route: appwriteFunctions.api.routes.pushTokens },
-            { functionId: appwriteFunctions.api.id, route: appwriteFunctions.api.routes.accountDelete },
-            { functionId: appwriteFunctions.api.id, route: appwriteFunctions.api.routes.oauthWebhook },
-            { functionId: appwriteFunctions.api.id, route: appwriteFunctions.api.routes.pollsRun },
-            { functionId: appwriteFunctions.worker.id, route: appwriteFunctions.worker.routes.supervisor },
-            { functionId: appwriteFunctions.worker.id, route: appwriteFunctions.worker.routes.jobsRun },
-        ].map(({ functionId, route }) => ({
-            context: route.context,
-            functionId,
-            method: route.method,
-            path: route.path,
-        }))).toEqual([
-            { context: 'authenticated', functionId: 'marco-api', method: 'POST', path: '/profile/ensure' },
-            { context: 'public', functionId: 'marco-api', method: 'POST', path: '/auth/send-code' },
-            { context: 'public', functionId: 'marco-api', method: 'POST', path: '/auth/verify-code' },
-            { context: 'authenticated', functionId: 'marco-api', method: 'POST', path: '/commands' },
-            { context: 'authenticated', functionId: 'marco-api', method: 'POST', path: '/accounts/connect' },
-            { context: 'authenticated', functionId: 'marco-api', method: 'POST', path: '/accounts/poll' },
-            { context: 'authenticated', functionId: 'marco-api', method: 'PUT', path: '/accounts/connection' },
-            { context: 'authenticated', functionId: 'marco-api', method: 'POST', path: '/push-tokens' },
-            { context: 'authenticated', functionId: 'marco-api', method: 'DELETE', path: '/account/delete' },
-            { context: 'webhook', functionId: 'marco-api', method: 'GET', path: '/v1/wh/oauth/callback' },
-            { context: 'internal', functionId: 'marco-api', method: 'POST', path: '/polls/run' },
-            { context: 'internal', functionId: 'marco-worker', method: 'POST', path: '/' },
-            { context: 'internal', functionId: 'marco-worker', method: 'POST', path: '/jobs/run' },
-        ]);
-    });
-    const authRoutes = [
-        {
-            request: { email: 'test-user-email-1@example.com', userId: 'test-appwrite-user-id-1' },
-            response: { userId: 'test-appwrite-user-id-1' },
-            route: () => appwriteFunctions.api.routes.authSendCode,
-        },
-        {
-            request: { code: '123456', email: 'test-user-email-1@example.com', userId: 'test-appwrite-user-id-1' },
-            response: { secret: 'test-appwrite-secret-1', userId: 'test-appwrite-user-id-1' },
-            route: () => appwriteFunctions.api.routes.authVerifyCode,
-        },
-    ];
-    for (const { request, response, route } of authRoutes) {
-        it(`accepts the public ${route().path} contract`, () => {
-            expect(v.safeParse(route().requestSchema, request).success).toBe(true);
-            expect(v.safeParse(route().responseSchema, response).success).toBe(true);
-        });
-        it(`rejects unknown fields in the public ${route().path} contract`, () => {
-            expect(v.safeParse(route().requestSchema, { ...request, unexpected: true }).success).toBe(false);
-            expect(v.safeParse(route().responseSchema, { ...response, unexpected: true }).success).toBe(false);
-        });
-    }
-    for (const { description, request, route } of [
-        {
-            description: 'malformed email',
-            request: { email: 'not-an-email', userId: 'test-appwrite-user-id-1' },
-            route: () => appwriteFunctions.api.routes.authSendCode,
-        },
-        {
-            description: 'malformed code',
-            request: { code: '12345', email: 'test-user-email-1@example.com', userId: 'test-appwrite-user-id-1' },
-            route: () => appwriteFunctions.api.routes.authVerifyCode,
-        },
-    ]) {
-        it(`rejects a public auth request with a ${description}`, () => {
-            expect(v.safeParse(route().requestSchema, request).success).toBe(false);
-        });
-    }
-    for (const { name, request, response, route } of routeFixtures) {
-        it(`accepts the ${name} request and response`, () => {
-            expect(v.safeParse(route().requestSchema, request).success).toBe(true);
-            expect(v.safeParse(route().responseSchema, response).success).toBe(true);
-        });
-        if (name !== 'OAuth webhook') {
-            it(`rejects caller ownership in the ${name} request and response`, () => {
-                expect(v.safeParse(route().requestSchema, { ...request, userId: 'another-user' }).success).toBe(false);
-                expect(v.safeParse(route().responseSchema, { ...response, userId: 'another-user' }).success).toBe(false);
-            });
-        }
-    }
-    it('accepts provider-owned OAuth callback parameters without passing them to the handler', () => {
-        const result = v.safeParse(appwriteFunctions.api.routes.oauthWebhook.requestSchema, {
-            authuser: '0',
-            code: 'test-authorisation-code-1',
-            iss: 'https://accounts.google.com',
-            scope: 'openid email profile',
-            state: 'test-state-1',
-        });
-        expect(result.success).toBe(true);
-        if (result.success) {
-            expect(result.output).toEqual({ code: 'test-authorisation-code-1', state: 'test-state-1' });
-        }
-    });
-    for (const { description, request } of [
-        { description: 'missing code', request: { state: 'test-state-1' } },
-        { description: 'empty code', request: { code: '', state: 'test-state-1' } },
-        { description: 'oversized code', request: { code: 'a'.repeat(4097), state: 'test-state-1' } },
-        { description: 'missing state', request: { code: 'test-authorisation-code-1' } },
-        { description: 'empty state', request: { code: 'test-authorisation-code-1', state: '' } },
-        { description: 'oversized state', request: { code: 'test-authorisation-code-1', state: 'a'.repeat(4097) } },
-    ]) {
-        it(`rejects an OAuth callback with ${description}`, () => {
-            expect(v.safeParse(appwriteFunctions.api.routes.oauthWebhook.requestSchema, request).success).toBe(false);
-        });
-    }
-    it('rejects caller-selected accounts for manual polling', () => {
-        const requestSchema = appwriteFunctions.api.routes.accountsPoll.requestSchema;
-        expect(v.safeParse(requestSchema, { accountId: 'account_1' }).success).toBe(false);
-        expect(v.safeParse(requestSchema, { accountIds: ['account_1'] }).success).toBe(false);
-    });
-    for (const { description, value } of [
-        { description: 'empty', value: '' },
-        { description: 'overlong', value: 'a'.repeat(37) },
-        { description: 'illegal', value: 'test/command/id/1' },
-    ]) {
-        it(`rejects an ${description} manual-poll command ID`, () => {
-            expect(v.safeParse(appwriteFunctions.api.routes.accountsPoll.responseSchema, {
-                commands: [{ accountId: 'test-account-id-1', commandId: value }],
-                failedAccountIds: [],
-            }).success).toBe(false);
-        });
-    }
-    const shardRoutes = [
-        {
-            description: 'poll',
-            request: { scheduledFor: '2026-07-23T12:00:30.000Z', shardId: 'test invalid shard id' },
-            requestSchema: appwriteFunctions.api.routes.pollsRun.requestSchema,
-        },
-    ];
-    for (const { description, request, requestSchema } of shardRoutes) {
-        it(`rejects a malformed ${description} shard ID`, () => {
-            expect(v.safeParse(requestSchema, request).success).toBe(false);
-        });
-    }
-    for (const { description, request } of [
-        { description: 'a missing scheduled slot', request: { shardId: 'test-poll-shard-id-1' } },
-        {
-            description: 'a malformed scheduled slot',
-            request: { scheduledFor: '2026-07-23 12:00:30', shardId: 'test-poll-shard-id-1' },
-        },
-        {
-            description: 'a calendar-impossible scheduled slot',
-            request: { scheduledFor: '2026-06-31T12:00:30.000Z', shardId: 'test-poll-shard-id-1' },
-        },
-        {
-            description: 'a non-canonical scheduled slot',
-            request: { scheduledFor: '2026-07-23T12:00:30.000+00:00', shardId: 'test-poll-shard-id-1' },
-        },
-        {
-            description: 'an extra field',
-            request: {
-                scheduledFor: '2026-07-23T12:00:30.000Z',
-                shardId: 'test-poll-shard-id-1',
-                unexpected: true,
-            },
-        },
-    ]) {
-        it(`rejects a poll request with ${description}`, () => {
-            expect(v.safeParse(appwriteFunctions.api.routes.pollsRun.requestSchema, request).success).toBe(false);
-        });
-    }
-    it('redacts credentials from connection responses and compact errors', () => {
-        expect(v.safeParse(appwriteFunctions.api.routes.accountsConnect.responseSchema, {
-            accountId: 'account_1',
-            credentials: { password: 'secret' },
-            state: 'CONNECTED',
-        }).success).toBe(false);
-        expect(v.safeParse(appwriteFunctions.errorSchema, {
-            code: 'AUTHENTICATION_FAILED',
-            retryable: false,
-        }).success).toBe(true);
-        expect(v.safeParse(appwriteFunctions.errorSchema, {
-            code: 'AUTHENTICATION_FAILED',
-            credentials: 'secret',
-            retryable: false,
-        }).success).toBe(false);
-    });
-    const invalidOAuthConnections = [
-        {
-            connection: {
-                kind: 'OAUTH',
-                provider: 'GMAIL',
-                returnUri: 'https://app.marcoapp.io/onboarding/provider-selection',
-            },
-            description: 'a missing mailbox email',
-            expected: false,
-        },
-        {
-            connection: {
-                email: 'not-an-email',
-                kind: 'OAUTH',
-                provider: 'GMAIL',
-                returnUri: 'https://app.marcoapp.io/onboarding/provider-selection',
-            },
-            description: 'a malformed mailbox email',
-            expected: false,
-        },
-    ];
-    const forbiddenOAuthReturnUris = [
-        { description: 'provider-selection', returnUri: 'https://app.marcoapp.io/onboarding/provider-selection' },
-        { description: 'staging loading', returnUri: 'https://app.staging.marcoapp.io/onboarding/loading' },
-        { description: 'arbitrary origin', returnUri: 'https://attacker.example/onboarding/loading' },
-        { description: 'arbitrary path', returnUri: 'https://app.marcoapp.io/onboarding/loading/unexpected' },
-    ];
-    const oauthConnectionRoutes = [
-        {
-            description: 'connect',
-            includesAccountId: false,
-            requestSchema: appwriteFunctions.api.routes.accountsConnect.requestSchema,
-        },
-        {
-            description: 'replacement',
-            includesAccountId: true,
-            requestSchema: appwriteFunctions.api.routes.accountConnection.requestSchema,
-        },
-    ];
-    for (const { description, includesAccountId, requestSchema } of oauthConnectionRoutes) {
-        it(`accepts ${description} OAuth connection completing at production loading`, () => {
-            const connection = {
-                email: 'test-user@example.com',
-                kind: 'OAUTH',
-                provider: 'GMAIL',
-                returnUri: 'https://app.marcoapp.io/onboarding/loading',
-            };
-            const request = includesAccountId ? { accountId: 'account_1', connection } : { connection };
-            expect(v.safeParse(requestSchema, request).success).toBe(true);
-        });
-    }
-    for (const { connection, description, expected } of invalidOAuthConnections) {
-        for (const { description: routeDescription, includesAccountId, requestSchema } of oauthConnectionRoutes) {
-            it(`rejects ${routeDescription} OAuth connection with ${description}`, () => {
-                const request = includesAccountId ? { accountId: 'account_1', connection } : { connection };
-                expect(v.safeParse(requestSchema, request).success).toBe(expected);
-            });
-        }
-    }
-    for (const { description, returnUri } of forbiddenOAuthReturnUris) {
-        for (const { description: routeDescription, includesAccountId, requestSchema } of oauthConnectionRoutes) {
-            it(`rejects ${routeDescription} OAuth connection with ${description} return URI`, () => {
-                const connection = {
-                    email: 'test-user@example.com',
-                    kind: 'OAUTH',
-                    provider: 'GMAIL',
-                    returnUri,
-                };
-                const request = includesAccountId ? { accountId: 'account_1', connection } : { connection };
-                expect(v.safeParse(requestSchema, request).success).toBe(false);
-            });
-        }
-    }
-});

package/dist/appwrite/index.d.ts

@@ -1,8 +0,0 @@
-export * from './appwrite.js';
-export * from './commands.js';
-export type { AppwriteDraftAttachment, AppwriteDraftEnvelope } from './decodedSchemas.js';
-export * from './functions.js';
-export type { AppwriteQueryConsumer, AppwriteQueryContract, AppwriteQueryContractName, AppwriteQueryIndexKind, AppwriteQueryIndexRequirement, AppwriteQueryIndexRequirementName, } from './queryContracts/queryContracts.js';
-export { appwriteQueryContractNames, appwriteQueryContracts, appwriteQueryIndexRequirementNames, appwriteQueryIndexRequirements, validateAppwriteQueryContracts, } from './queryContracts/queryContracts.js';
-export { type AppwriteColumnDefinition, type AppwriteColumnSchema, type AppwriteColumnType, type AppwriteDataRow, type AppwriteIndexDefinition, type AppwriteIndexType, type AppwriteMailboxSyncLane, type AppwriteMailboxSyncLaneState, type AppwriteMailboxSyncState, type AppwritePollShardState, type AppwriteRelationshipDefinition, type AppwriteRelationshipOnDelete, type AppwriteRelationshipSchema, type AppwriteRelationshipType, type AppwriteRow, type AppwriteRowTable, type AppwriteTableDefinition, type AppwriteTableIndexAttributeKey, type AppwriteTableId, type AppwriteTableInput, type AppwriteTableKey, accountProviders, accountStates, appwriteDataSchemas, appwriteRelationshipIdSchema, appwriteRowSchemas, appwriteTableContract, appwriteTableIdSchema, appwriteTableIds, appwriteTables, commandStates, defineAppwriteTables, draftStates, draftTypes, jobStates, labelSpecialUses, mailboxSyncLaneStates, mailboxSyncLanes, mailboxSyncProvisionedStates, mailboxSyncStates, oauthOperations, oauthProviders, oauthReturnUriSchema, oauthReturnUris, pollShardStates, } from './tableContract/index.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/appwrite/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/appwrite/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA;AAC1B,YAAY,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAA;AACtF,cAAc,aAAa,CAAA;AAC3B,YAAY,EACV,qBAAqB,EACrB,qBAAqB,EACrB,yBAAyB,EACzB,sBAAsB,EACtB,6BAA6B,EAC7B,iCAAiC,GAClC,MAAM,iCAAiC,CAAA;AACxC,OAAO,EACL,0BAA0B,EAC1B,sBAAsB,EACtB,kCAAkC,EAClC,8BAA8B,EAC9B,8BAA8B,GAC/B,MAAM,iCAAiC,CAAA;AACxC,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,uBAAuB,EAC5B,KAAK,iBAAiB,EACtB,KAAK,uBAAuB,EAC5B,KAAK,4BAA4B,EACjC,KAAK,wBAAwB,EAC7B,KAAK,sBAAsB,EAC3B,KAAK,8BAA8B,EACnC,KAAK,4BAA4B,EACjC,KAAK,0BAA0B,EAC/B,KAAK,wBAAwB,EAC7B,KAAK,WAAW,EAChB,KAAK,gBAAgB,EACrB,KAAK,uBAAuB,EAC5B,KAAK,8BAA8B,EACnC,KAAK,eAAe,EACpB,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EACrB,gBAAgB,EAChB,aAAa,EACb,mBAAmB,EACnB,4BAA4B,EAC5B,kBAAkB,EAClB,qBAAqB,EACrB,qBAAqB,EACrB,gBAAgB,EAChB,cAAc,EACd,aAAa,EACb,oBAAoB,EACpB,WAAW,EACX,UAAU,EACV,SAAS,EACT,gBAAgB,EAChB,qBAAqB,EACrB,gBAAgB,EAChB,4BAA4B,EAC5B,iBAAiB,EACjB,eAAe,EACf,cAAc,EACd,oBAAoB,EACpB,eAAe,EACf,eAAe,GAChB,MAAM,iBAAiB,CAAA"}

package/dist/appwrite/index.js

@@ -1,5 +0,0 @@
-export * from './appwrite.js';
-export * from './commands.js';
-export * from './functions.js';
-export { appwriteQueryContractNames, appwriteQueryContracts, appwriteQueryIndexRequirementNames, appwriteQueryIndexRequirements, validateAppwriteQueryContracts, } from './queryContracts/queryContracts.js';
-export { accountProviders, accountStates, appwriteDataSchemas, appwriteRelationshipIdSchema, appwriteRowSchemas, appwriteTableContract, appwriteTableIdSchema, appwriteTableIds, appwriteTables, commandStates, defineAppwriteTables, draftStates, draftTypes, jobStates, labelSpecialUses, mailboxSyncLaneStates, mailboxSyncLanes, mailboxSyncProvisionedStates, mailboxSyncStates, oauthOperations, oauthProviders, oauthReturnUriSchema, oauthReturnUris, pollShardStates, } from './tableContract/index.js';