@marcoappio/marco-config 2.0.492 → 2.0.493

package/dist/zero/mutators/mutators.js

@@ -1,39 +1,12 @@
-import * as v from 'valibot';
-import { zeroMutatorSchemas } from '../../zero/mutatorSchemas';
-import { createAccountMutators } from './accountMutators';
-import { createDraftMutators } from './draftMutators';
-import { createThreadMutators } from './threadMutators';
-import { createUserMutators } from './userMutators';
-const validateArgs = (schema, input) => {
-    const parsed = v.safeParse(schema, input);
-    if (!parsed.success) {
-        throw new ZeroMutatorValidationError(v.flatten(parsed.issues));
-    }
-    return parsed.output;
-};
-const createValidatingMutator = (schema, handler) => {
-    return async (tx, input) => {
-        const args = validateArgs(schema, input);
-        await handler(tx, args);
-    };
-};
-const buildMutatorMap = (defs, handlers) => {
-    const entries = Object.entries(defs).map(([name, definition]) => [
-        name,
-        createValidatingMutator(definition.delta, handlers[name]),
-    ]);
-    return Object.fromEntries(entries);
-};
-export class ZeroMutatorValidationError extends Error {
-    issues;
-    constructor(issues) {
-        super('Zero mutator payload failed validation');
-        this.issues = issues;
-    }
-}
-export const createMutators = (authData) => ({
-    account: buildMutatorMap(zeroMutatorSchemas.account, createAccountMutators(authData)),
-    draft: buildMutatorMap(zeroMutatorSchemas.draft, createDraftMutators(authData)),
-    thread: buildMutatorMap(zeroMutatorSchemas.thread, createThreadMutators(authData)),
-    user: buildMutatorMap(zeroMutatorSchemas.user, createUserMutators(authData)),
+import { defineMutators } from '@rocicorp/zero';
+import { accountMutators } from './accountMutators';
+import { draftMutators } from './draftMutators';
+import { threadMutators } from './threadMutators';
+import { userMutators } from './userMutators';
+export { defineMutator } from './defineMutator';
+export const mutators = defineMutators({
+    account: accountMutators,
+    draft: draftMutators,
+    thread: threadMutators,
+    user: userMutators,
 });

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

@@ -1,8 +1,132 @@
 import type { Transaction } from '@rocicorp/zero';
 import type { LabelSpecialUse } from '../../../types';
-import { type AuthData, type HandlerMap } from '../../../types';
-import type { ZeroMutatorSchemas } from '../../../zero/mutatorSchemas';
 import type { MarcoZeroSchema } from '../../../zero/schema';
 export declare const setSystemLabel: (tx: Transaction<MarcoZeroSchema>, threadId: string, targetSpecialUse: LabelSpecialUse) => Promise<void>;
-export declare const createThreadMutators: (_authData: AuthData | undefined) => HandlerMap<ZeroMutatorSchemas["thread"]>;
+export declare const threadMutators: {
+    addLabel: import("@rocicorp/zero").MutatorDefinition<{
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+        labelPath: string;
+    }, {
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+        labelPath: string;
+    }, import("../../../zero/mutators/defineMutator").MarcoZeroContext>;
+    delete: import("@rocicorp/zero").MutatorDefinition<{
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+    }, {
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+    }, import("../../../zero/mutators/defineMutator").MarcoZeroContext>;
+    removeLabel: import("@rocicorp/zero").MutatorDefinition<{
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+        labelPath: string;
+    }, {
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+        labelPath: string;
+    }, import("../../../zero/mutators/defineMutator").MarcoZeroContext>;
+    setArchive: import("@rocicorp/zero").MutatorDefinition<{
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+    }, {
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+    }, import("../../../zero/mutators/defineMutator").MarcoZeroContext>;
+    setFlagged: import("@rocicorp/zero").MutatorDefinition<{
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+        flagged: boolean;
+    }, {
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+        flagged: boolean;
+    }, import("../../../zero/mutators/defineMutator").MarcoZeroContext>;
+    setInbox: import("@rocicorp/zero").MutatorDefinition<{
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+    }, {
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+    }, import("../../../zero/mutators/defineMutator").MarcoZeroContext>;
+    setSeen: import("@rocicorp/zero").MutatorDefinition<{
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+        seen: boolean;
+    }, {
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+        seen: boolean;
+    }, import("../../../zero/mutators/defineMutator").MarcoZeroContext>;
+    setSpam: import("@rocicorp/zero").MutatorDefinition<{
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+    }, {
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+    }, import("../../../zero/mutators/defineMutator").MarcoZeroContext>;
+    setTrash: import("@rocicorp/zero").MutatorDefinition<{
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+    }, {
+        accounts: {
+            [x: string]: {
+                threadIds: string[];
+            };
+        };
+    }, import("../../../zero/mutators/defineMutator").MarcoZeroContext>;
+};
 //# sourceMappingURL=threadMutators.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"threadMutators.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/threadMutators/threadMutators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAEjD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAC1D,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,UAAU,EAAiB,MAAM,qBAAqB,CAAA;AAEnF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAA;AAC3E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAIhE,eAAO,MAAM,cAAc,OACrB,WAAW,CAAC,eAAe,CAAC,YACtB,MAAM,oBACE,eAAe,KAChC,OAAO,CAAC,IAAI,CAyFd,CAAA;AAED,eAAO,MAAM,oBAAoB,cAAe,QAAQ,GAAG,SAAS,KAAG,UAAU,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CA0O5G,CAAA"}
+{"version":3,"file":"threadMutators.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/threadMutators/threadMutators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAIjD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAI1D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAoBhE,eAAO,MAAM,cAAc,OACrB,WAAW,CAAC,eAAe,CAAC,YACtB,MAAM,oBACE,eAAe,KAChC,OAAO,CAAC,IAAI,CAyFd,CAAA;AAED,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsP1B,CAAA"}

package/dist/zero/mutators/threadMutators/threadMutators.js

@@ -1,6 +1,19 @@
+import * as v from 'valibot';
+import { marcoSchemas } from '../../../schemas';
 import { MutationError } from '../../../types';
 import { threadsUtils } from '../../../utils/threads';
+import { defineMutator } from '../../../zero/mutators/defineMutator';
 const buildLabelIdList = (x) => (x.length === 0 ? '' : ` ${[...new Set(x)].join(' ')} `);
+const accountsSchema = v.record(marcoSchemas.string.required(), v.object({
+    threadIds: v.array(marcoSchemas.string.required()),
+}));
+const baseThreadSchema = v.object({
+    accounts: accountsSchema,
+});
+const threadChangeLabelSchema = v.object({
+    accounts: accountsSchema,
+    labelPath: marcoSchemas.string.required(),
+});
 export const setSystemLabel = async (tx, threadId, targetSpecialUse) => {
     const thread = await tx.query.thread.where('id', threadId).one().run();
     if (!thread) {
@@ -70,8 +83,8 @@ export const setSystemLabel = async (tx, threadId, targetSpecialUse) => {
         labelIdList: buildLabelIdList([targetLabel.id]),
     });
 };
-export const createThreadMutators = (_authData) => ({
-    addLabel: async (tx, args) => {
+export const threadMutators = {
+    addLabel: defineMutator(threadChangeLabelSchema, async ({ tx, args }) => {
         for (const [accountId, { threadIds }] of Object.entries(args.accounts)) {
             const label = await tx.query.accountLabel.where('accountId', accountId).where('path', args.labelPath).one().run();
             if (!label) {
@@ -124,8 +137,8 @@ export const createThreadMutators = (_authData) => ({
                 });
             }
         }
-    },
-    delete: async (tx, args) => {
+    }),
+    delete: defineMutator(baseThreadSchema, async ({ tx, args }) => {
         for (const [, { threadIds }] of Object.entries(args.accounts)) {
             for (const threadId of threadIds) {
                 const thread = await tx.query.thread.where('id', threadId).one().run();
@@ -146,8 +159,8 @@ export const createThreadMutators = (_authData) => ({
                 }
             }
         }
-    },
-    removeLabel: async (tx, args) => {
+    }),
+    removeLabel: defineMutator(threadChangeLabelSchema, async ({ tx, args }) => {
         for (const [accountId, { threadIds }] of Object.entries(args.accounts)) {
             const label = await tx.query.accountLabel.where('accountId', accountId).where('path', args.labelPath).one().run();
             if (!label) {
@@ -191,30 +204,36 @@ export const createThreadMutators = (_authData) => ({
                 ]);
             }
         }
-    },
-    setArchive: async (tx, args) => {
+    }),
+    setArchive: defineMutator(baseThreadSchema, async ({ tx, args }) => {
         for (const [, { threadIds }] of Object.entries(args.accounts)) {
             for (const threadId of threadIds) {
                 await setSystemLabel(tx, threadId, 'ARCHIVE');
             }
         }
-    },
-    setFlagged: async (tx, args) => {
+    }),
+    setFlagged: defineMutator(v.object({
+        accounts: accountsSchema,
+        flagged: v.nonOptional(v.boolean()),
+    }), async ({ tx, args }) => {
         for (const [, { threadIds }] of Object.entries(args.accounts)) {
             await Promise.all(threadIds.map(threadId => tx.mutate.thread.update({
                 flagged: args.flagged,
                 id: threadId,
             })));
         }
-    },
-    setInbox: async (tx, args) => {
+    }),
+    setInbox: defineMutator(baseThreadSchema, async ({ tx, args }) => {
         for (const [, { threadIds }] of Object.entries(args.accounts)) {
             for (const threadId of threadIds) {
                 await setSystemLabel(tx, threadId, 'INBOX');
             }
         }
-    },
-    setSeen: async (tx, args) => {
+    }),
+    setSeen: defineMutator(v.object({
+        accounts: accountsSchema,
+        seen: v.boolean(),
+    }), async ({ tx, args }) => {
         const allThreadIds = Object.values(args.accounts).flatMap(x => x.threadIds);
         const threads = await tx.query.thread.where('id', 'IN', allThreadIds).run();
         const labelCounts = new Map();
@@ -239,19 +258,19 @@ export const createThreadMutators = (_authData) => ({
             id: threadId,
             seen: args.seen,
         })));
-    },
-    setSpam: async (tx, args) => {
+    }),
+    setSpam: defineMutator(baseThreadSchema, async ({ tx, args }) => {
         for (const [, { threadIds }] of Object.entries(args.accounts)) {
             for (const threadId of threadIds) {
                 await setSystemLabel(tx, threadId, 'SPAM');
             }
         }
-    },
-    setTrash: async (tx, args) => {
+    }),
+    setTrash: defineMutator(baseThreadSchema, async ({ tx, args }) => {
         for (const [, { threadIds }] of Object.entries(args.accounts)) {
             for (const threadId of threadIds) {
                 await setSystemLabel(tx, threadId, 'TRASH');
             }
         }
-    },
-});
+    }),
+};

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

@@ -1,4 +1,32 @@
-import type { AuthData, HandlerMap } from '../../../types';
-import type { ZeroMutatorSchemas } from '../../../zero/mutatorSchemas';
-export declare const createUserMutators: (_authData: AuthData | undefined) => HandlerMap<ZeroMutatorSchemas["user"]>;
+export declare const userMutators: {
+    deleteSettingsPushNotificationToken: import("@rocicorp/zero").MutatorDefinition<{
+        id: string;
+        token: string;
+    }, {
+        id: string;
+        token: string;
+    }, import("../../../zero/mutators/defineMutator").MarcoZeroContext>;
+    setSettingsName: import("@rocicorp/zero").MutatorDefinition<{
+        id: string;
+        name: string | null;
+    }, {
+        id: string;
+        name: string | null;
+    }, import("../../../zero/mutators/defineMutator").MarcoZeroContext>;
+    setSettingsPushNotificationToken: import("@rocicorp/zero").MutatorDefinition<{
+        id: string;
+        pushNotificationToken: {
+            createdAt: number;
+            id: string;
+            token: string;
+        };
+    }, {
+        id: string;
+        pushNotificationToken: {
+            createdAt: number;
+            id: string;
+            token: string;
+        };
+    }, import("../../../zero/mutators/defineMutator").MarcoZeroContext>;
+};
 //# sourceMappingURL=userMutators.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"userMutators.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/userMutators/userMutators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAC/D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAA;AAE3E,eAAO,MAAM,kBAAkB,cAAe,QAAQ,GAAG,SAAS,KAAG,UAAU,CAAC,kBAAkB,CAAC,MAAM,CAAC,CA4BxG,CAAA"}
+{"version":3,"file":"userMutators.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/userMutators/userMutators.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8CxB,CAAA"}

package/dist/zero/mutators/userMutators/userMutators.js

@@ -1,16 +1,33 @@
-export const createUserMutators = (_authData) => ({
-    deleteSettingsPushNotificationToken: async (tx, args) => {
+import * as v from 'valibot';
+import { marcoSchemas } from '../../../schemas';
+import { defineMutator } from '../../../zero/mutators/defineMutator';
+const userPushNotificationTokenSchema = v.object({
+    createdAt: marcoSchemas.number.positiveInteger(),
+    id: marcoSchemas.string.required(),
+    token: marcoSchemas.string.required(),
+});
+export const userMutators = {
+    deleteSettingsPushNotificationToken: defineMutator(v.object({
+        id: marcoSchemas.string.required(),
+        token: marcoSchemas.string.required(),
+    }), async ({ tx, args }) => {
         await tx.mutate.userPushNotificationToken.delete({
             id: args.id,
         });
-    },
-    setSettingsName: async (tx, args) => {
+    }),
+    setSettingsName: defineMutator(v.object({
+        id: marcoSchemas.string.required(),
+        name: marcoSchemas.string.nullable(),
+    }), async ({ tx, args }) => {
         await tx.mutate.user.update({
             id: args.id,
             name: args.name,
         });
-    },
-    setSettingsPushNotificationToken: async (tx, args) => {
+    }),
+    setSettingsPushNotificationToken: defineMutator(v.object({
+        id: marcoSchemas.string.required(),
+        pushNotificationToken: userPushNotificationTokenSchema,
+    }), async ({ tx, args }) => {
         const existing = await tx.query.userPushNotificationToken
             .where('userId', args.id)
             .where('token', args.pushNotificationToken.token)
@@ -24,5 +41,5 @@ export const createUserMutators = (_authData) => ({
                 userId: args.id,
             });
         }
-    },
-});
+    }),
+};