@marcoappio/marco-config 2.0.504 → 2.0.506

package/dist/zero/mutators/accountMutators/accountMutators.d.ts

@@ -1,189 +1,4 @@
-import * as v from 'valibot';
-export declare const accountMutatorSchemas: {
-    createAccount: v.ObjectSchema<{
-        readonly aliasId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        readonly color: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        readonly emailAddress: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
-        readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-    }, undefined>;
-    createAlias: v.ObjectSchema<{
-        readonly accountId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        readonly alias: v.ObjectSchema<{
-            readonly emailAddress: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.EmailAction<string, undefined>, v.MaxLengthAction<string, 255, undefined>]>, undefined>;
-            readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly name: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        }, undefined>;
-    }, undefined>;
-    deleteAccount: v.ObjectSchema<{
-        readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-    }, undefined>;
-    deleteAlias: v.ObjectSchema<{
-        readonly accountId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        readonly aliasId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-    }, undefined>;
-    setAliasName: v.ObjectSchema<{
-        readonly accountId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        readonly aliasId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        readonly displayName: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-    }, undefined>;
-    setAliasPrimary: v.ObjectSchema<{
-        readonly accountId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        readonly aliasId: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-    }, undefined>;
-    setConnectionConfigImapRaw: v.ObjectSchema<{
-        readonly connectionConfig: v.ObjectSchema<{
-            readonly imapHost: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly imapPassword: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly imapPort: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, number, undefined>, v.MaxValueAction<number, number, undefined>]>, undefined>;
-            readonly imapSocketType: v.UnionSchema<[v.LiteralSchema<"STARTTLS", undefined>, v.LiteralSchema<"SSL", undefined>], undefined>;
-            readonly imapUser: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly smtpHost: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly smtpPassword: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly smtpPort: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, number, undefined>, v.MaxValueAction<number, number, undefined>]>, undefined>;
-            readonly smtpSocketType: v.UnionSchema<[v.LiteralSchema<"STARTTLS", undefined>, v.LiteralSchema<"SSL", undefined>], undefined>;
-            readonly smtpUser: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        }, undefined>;
-        readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-    }, undefined>;
-    setConnectionConfigOauth: v.ObjectSchema<{
-        readonly connectionConfig: v.ObjectSchema<{
-            readonly code: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-            readonly provider: v.PicklistSchema<readonly ["GOOGLE", "OUTLOOK"], undefined>;
-            readonly user: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        }, undefined>;
-        readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-    }, undefined>;
-    setSettings: v.ObjectSchema<{
-        readonly color: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-        readonly displayName: v.OptionalSchema<v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>, undefined>;
-        readonly id: v.NonOptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.NonEmptyAction<string, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-    }, undefined>;
-};
-export declare const accountMutators: {
-    createAccount: import("@rocicorp/zero").MutatorDefinition<{
-        aliasId: string;
-        color: string;
-        emailAddress: string;
-        id: string;
-    }, {
-        aliasId: string;
-        color: string;
-        emailAddress: string;
-        id: string;
-    }, {
-        readonly userId: string;
-    }, unknown>;
-    createAlias: import("@rocicorp/zero").MutatorDefinition<{
-        accountId: string;
-        alias: {
-            emailAddress: string;
-            id: string;
-            name: string | null;
-        };
-    }, {
-        accountId: string;
-        alias: {
-            emailAddress: string;
-            id: string;
-            name: string | null;
-        };
-    }, {
-        readonly userId: string;
-    }, unknown>;
-    deleteAccount: import("@rocicorp/zero").MutatorDefinition<{
-        id: string;
-    }, {
-        id: string;
-    }, {
-        readonly userId: string;
-    }, unknown>;
-    deleteAlias: import("@rocicorp/zero").MutatorDefinition<{
-        accountId: string;
-        aliasId: string;
-    }, {
-        accountId: string;
-        aliasId: string;
-    }, {
-        readonly userId: string;
-    }, unknown>;
-    setAliasName: import("@rocicorp/zero").MutatorDefinition<{
-        accountId: string;
-        aliasId: string;
-        displayName: string | null;
-    }, {
-        accountId: string;
-        aliasId: string;
-        displayName: string | null;
-    }, {
-        readonly userId: string;
-    }, unknown>;
-    setAliasPrimary: import("@rocicorp/zero").MutatorDefinition<{
-        accountId: string;
-        aliasId: string;
-    }, {
-        accountId: string;
-        aliasId: string;
-    }, {
-        readonly userId: string;
-    }, unknown>;
-    setConnectionConfigImapRaw: import("@rocicorp/zero").MutatorDefinition<{
-        connectionConfig: {
-            imapHost: string;
-            imapPassword: string;
-            imapPort: number;
-            imapSocketType: "STARTTLS" | "SSL";
-            imapUser: string;
-            smtpHost: string;
-            smtpPassword: string;
-            smtpPort: number;
-            smtpSocketType: "STARTTLS" | "SSL";
-            smtpUser: string;
-        };
-        id: string;
-    }, {
-        connectionConfig: {
-            imapHost: string;
-            imapPassword: string;
-            imapPort: number;
-            imapSocketType: "STARTTLS" | "SSL";
-            imapUser: string;
-            smtpHost: string;
-            smtpPassword: string;
-            smtpPort: number;
-            smtpSocketType: "STARTTLS" | "SSL";
-            smtpUser: string;
-        };
-        id: string;
-    }, {
-        readonly userId: string;
-    }, unknown>;
-    setConnectionConfigOauth: import("@rocicorp/zero").MutatorDefinition<{
-        connectionConfig: {
-            code: string;
-            provider: "GOOGLE" | "OUTLOOK";
-            user: string;
-        };
-        id: string;
-    }, {
-        connectionConfig: {
-            code: string;
-            provider: "GOOGLE" | "OUTLOOK";
-            user: string;
-        };
-        id: string;
-    }, {
-        readonly userId: string;
-    }, unknown>;
-    setSettings: import("@rocicorp/zero").MutatorDefinition<{
-        color?: string | null | undefined;
-        displayName?: string | null | undefined;
-        id: string;
-    }, {
-        color?: string | null | undefined;
-        displayName?: string | null | undefined;
-        id: string;
-    }, {
-        readonly userId: string;
-    }, unknown>;
-};
+import { type AuthData, type HandlerMap } from '../../../types';
+import type { ZeroMutatorSchemas } from '../../../zero/mutatorSchemas';
+export declare const createAccountMutators: (authData: AuthData | undefined) => HandlerMap<ZeroMutatorSchemas["account"]>;
 //# sourceMappingURL=accountMutators.d.ts.map

package/dist/zero/mutators/accountMutators/accountMutators.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"accountMutators.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/accountMutators/accountMutators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAO5B,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4CjC,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8H3B,CAAA"}
+{"version":3,"file":"accountMutators.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/accountMutators/accountMutators.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,UAAU,EAAiB,MAAM,qBAAqB,CAAA;AACnF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAA;AAE3E,eAAO,MAAM,qBAAqB,aAAc,QAAQ,GAAG,SAAS,KAAG,UAAU,CAAC,kBAAkB,CAAC,SAAS,CAAC,CA2G7G,CAAA"}

package/dist/zero/mutators/accountMutators/accountMutators.js

@@ -1,139 +1,103 @@
-import * as v from 'valibot';
-import { marcoSchemas } from '../../../schemas';
-import { zeroCRUD } from '../../../zero/crud';
-import { defineMutator } from '../../../zero/mutators/typedMutator';
-import { z } from '../../../zero/queries/z';
-export const accountMutatorSchemas = {
-    createAccount: v.object({
-        aliasId: marcoSchemas.string.required(),
-        color: marcoSchemas.string.required(),
-        emailAddress: marcoSchemas.string.email(),
-        id: marcoSchemas.string.required(),
-    }),
-    createAlias: v.object({
-        accountId: marcoSchemas.string.required(),
-        alias: v.object({
-            emailAddress: marcoSchemas.string.email(),
-            id: marcoSchemas.string.required(),
-            name: marcoSchemas.string.nullable(),
-        }),
-    }),
-    deleteAccount: v.object({
-        id: marcoSchemas.string.required(),
-    }),
-    deleteAlias: v.object({
-        accountId: marcoSchemas.string.required(),
-        aliasId: marcoSchemas.string.required(),
-    }),
-    setAliasName: v.object({
-        accountId: marcoSchemas.string.required(),
-        aliasId: marcoSchemas.string.required(),
-        displayName: marcoSchemas.string.nullable(),
-    }),
-    setAliasPrimary: v.object({
-        accountId: marcoSchemas.string.required(),
-        aliasId: marcoSchemas.string.required(),
-    }),
-    setConnectionConfigImapRaw: v.object({
-        connectionConfig: marcoSchemas.emailAccount.connectionConfigImapRaw(),
-        id: marcoSchemas.string.required(),
-    }),
-    setConnectionConfigOauth: v.object({
-        connectionConfig: marcoSchemas.emailAccount.connectionConfigOauth(),
-        id: marcoSchemas.string.required(),
-    }),
-    setSettings: v.object({
-        color: v.optional(marcoSchemas.string.nullable()),
-        displayName: v.optional(marcoSchemas.string.nullable()),
-        id: marcoSchemas.string.required(),
-    }),
-};
-export const accountMutators = {
-    createAccount: defineMutator(accountMutatorSchemas.createAccount, async ({ tx, ctx: { userId }, args: { color, id, aliasId, emailAddress } }) => {
-        await tx.mutate(zeroCRUD.account.insert({
-            color,
+import { MutationError } from '../../../types';
+export const createAccountMutators = (authData) => ({
+    createAccount: async (tx, args) => {
+        if (!authData) {
+            throw new Error(MutationError.AUTHENTICATION_REQUIRED);
+        }
+        await tx.mutate.account.insert({
+            color: args.color,
             displayName: null,
-            id,
+            id: args.id,
             imapConnectionStatus: 'AWAITING_CONNECTION',
             mailProcessedCount: 0,
             mailTotalCount: 0,
-            primaryAliasId: aliasId,
-            userId,
-        }));
-        await tx.mutate(zeroCRUD.accountAlias.insert({
-            accountId: id,
-            emailAddress,
-            id: aliasId,
+            primaryAliasId: args.aliasId,
+            userId: authData.sub,
+        });
+        await tx.mutate.accountAlias.insert({
+            accountId: args.id,
+            emailAddress: args.emailAddress,
+            id: args.aliasId,
             isPrimary: true,
             name: null,
-        }));
-    }),
-    createAlias: defineMutator(accountMutatorSchemas.createAlias, async ({ tx, args: { accountId, alias } }) => {
-        await tx.mutate(zeroCRUD.accountAlias.insert({
-            accountId: accountId,
-            emailAddress: alias.emailAddress,
-            id: alias.id,
+        });
+    },
+    createAlias: async (tx, args) => {
+        await tx.mutate.accountAlias.insert({
+            accountId: args.accountId,
+            emailAddress: args.alias.emailAddress,
+            id: args.alias.id,
             isPrimary: false,
-            name: alias.name ?? null,
-        }));
-    }),
-    deleteAccount: defineMutator(accountMutatorSchemas.deleteAccount, async ({ tx, args: { id } }) => {
-        await tx.mutate(zeroCRUD.account.delete({ id }));
-    }),
-    deleteAlias: defineMutator(accountMutatorSchemas.deleteAlias, async ({ tx, args: { accountId, aliasId } }) => {
-        const alias = await tx.run(z.accountAlias.where('id', aliasId).one());
-        await tx.mutate(zeroCRUD.accountAlias.delete({ id: aliasId }));
+            name: args.alias.name ?? null,
+        });
+    },
+    deleteAccount: async (tx, args) => {
+        await tx.mutate.account.delete({
+            id: args.id,
+        });
+    },
+    deleteAlias: async (tx, args) => {
+        const alias = await tx.query.accountAlias.where('id', args.aliasId).one().run();
+        await tx.mutate.accountAlias.delete({
+            id: args.aliasId,
+        });
         if (alias?.isPrimary) {
-            const remainingAliases = await tx.run(z.accountAlias.where('accountId', accountId));
+            const remainingAliases = await tx.query.accountAlias.where('accountId', args.accountId).run();
             if (remainingAliases.length > 0) {
                 const newPrimaryAlias = remainingAliases[0];
-                await tx.mutate(zeroCRUD.accountAlias.update({
+                await tx.mutate.accountAlias.update({
                     id: newPrimaryAlias.id,
                     isPrimary: true,
-                }));
-                await tx.mutate(zeroCRUD.account.update({
-                    id: accountId,
+                });
+                await tx.mutate.account.update({
+                    id: args.accountId,
                     primaryAliasId: newPrimaryAlias.id,
-                }));
+                });
             }
             else {
-                await tx.mutate(zeroCRUD.account.update({
-                    id: accountId,
+                await tx.mutate.account.update({
+                    id: args.accountId,
                     primaryAliasId: null,
-                }));
+                });
             }
         }
-    }),
-    setAliasName: defineMutator(accountMutatorSchemas.setAliasName, async ({ tx, args: { aliasId, displayName } }) => {
-        await tx.mutate(zeroCRUD.accountAlias.update({
-            id: aliasId,
-            name: displayName,
-        }));
-    }),
-    setAliasPrimary: defineMutator(accountMutatorSchemas.setAliasPrimary, async ({ tx, args: { accountId, aliasId } }) => {
-        const aliases = await tx.run(z.accountAlias.where('accountId', accountId));
+    },
+    setAliasName: async (tx, args) => {
+        await tx.mutate.accountAlias.update({
+            id: args.aliasId,
+            name: args.displayName,
+        });
+    },
+    setAliasPrimary: async (tx, args) => {
+        const aliases = await tx.query.accountAlias.where('accountId', args.accountId).run();
         for (const alias of aliases) {
-            await tx.mutate(zeroCRUD.accountAlias.update({
+            await tx.mutate.accountAlias.update({
                 id: alias.id,
-                isPrimary: alias.id === aliasId,
-            }));
+                isPrimary: alias.id === args.aliasId,
+            });
         }
-        await tx.mutate(zeroCRUD.account.update({
-            id: accountId,
-            primaryAliasId: aliasId,
-        }));
-    }),
-    setConnectionConfigImapRaw: defineMutator(accountMutatorSchemas.setConnectionConfigImapRaw, async ({ tx, args: { id } }) => {
-        await tx.mutate(zeroCRUD.account.update({ id, imapConnectionStatus: 'AWAITING_CONNECTION' }));
-    }),
-    setConnectionConfigOauth: defineMutator(accountMutatorSchemas.setConnectionConfigOauth, async ({ tx, args: { id } }) => {
-        await tx.mutate(zeroCRUD.account.update({ id, imapConnectionStatus: 'AWAITING_CONNECTION' }));
-    }),
-    setSettings: defineMutator(accountMutatorSchemas.setSettings, async ({ tx, args: { id, color, displayName } }) => {
-        await tx.mutate(zeroCRUD.account.update({
-            color: color ? color : undefined,
-            displayName: displayName ? displayName : undefined,
-            id,
-        }));
-    }),
-};
+        await tx.mutate.account.update({
+            id: args.accountId,
+            primaryAliasId: args.aliasId,
+        });
+    },
+    setConnectionConfigImapRaw: async (tx, args) => {
+        await tx.mutate.account.update({
+            id: args.id,
+            imapConnectionStatus: 'AWAITING_CONNECTION',
+        });
+    },
+    setConnectionConfigOauth: async (tx, args) => {
+        await tx.mutate.account.update({
+            id: args.id,
+            imapConnectionStatus: 'AWAITING_CONNECTION',
+        });
+    },
+    setSettings: async (tx, args) => {
+        await tx.mutate.account.update({
+            color: args.color ? args.color : undefined,
+            displayName: args.displayName ? args.displayName : undefined,
+            id: args.id,
+        });
+    },
+});

package/dist/zero/mutators/accountMutators/accountMutators.test.d.ts

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

package/dist/zero/mutators/accountMutators/accountMutators.test.d.ts.map

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