@marcoappio/marco-config 2.0.491 → 2.0.493

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

@@ -1 +1 @@
-{"version":3,"file":"mutators.d.ts","sourceRoot":"","sources":["../../../src/zero/mutators/mutators.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAE5B,OAAO,KAAK,EAAkD,UAAU,EAAE,MAAM,qBAAqB,CAAA;AACrG,OAAO,EAAE,KAAK,kBAAkB,EAAsB,MAAM,mCAAmC,CAAA;AAG/F,OAAO,EAAE,KAAK,uBAAuB,EAAyB,MAAM,mBAAmB,CAAA;AACvF,OAAO,EAAuB,KAAK,qBAAqB,EAAE,MAAM,iBAAiB,CAAA;AACjF,OAAO,EAAwB,KAAK,sBAAsB,EAAE,MAAM,kBAAkB,CAAA;AACpF,OAAO,EAAsB,KAAK,oBAAoB,EAAE,MAAM,gBAAgB,CAAA;AAE9E,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,CAAC,EAAE,uBAAuB,CAAA;IACjC,KAAK,CAAC,EAAE,qBAAqB,CAAA;IAC7B,MAAM,CAAC,EAAE,sBAAsB,CAAA;IAC/B,IAAI,CAAC,EAAE,oBAAoB,CAAA;CAC5B,CAAA;AA8BD,qBAAa,0BAA2B,SAAQ,KAAK;IACvC,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC;gBAApC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC;CAG1D;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,UAAU,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC,CAAA;IAClD,KAAK,EAAE,UAAU,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC,CAAA;IAC9C,MAAM,EAAE,UAAU,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAC,CAAA;IAChD,IAAI,EAAE,UAAU,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC,CAAA;CAC7C,CAAA;AAED,eAAO,MAAM,cAAc,cAAe,QAAQ,cAAc,gBAAgB,KAAG,iBAKjF,CAAA;AAEF,YAAY,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,CAAA;AAC5G,MAAM,MAAM,QAAQ,GAAG;IACrB,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA"}
+{"version":3,"file":"mutators.d.ts","sourceRoot":"","sources":["../../../src/zero/mutators/mutators.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,aAAa,EAAE,KAAK,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AAEtE,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAKnB,CAAA;AAEF,MAAM,MAAM,iBAAiB,GAAG,OAAO,QAAQ,CAAA"}

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, callbacks) => ({
-    account: buildMutatorMap(zeroMutatorSchemas.account, createAccountMutators(authData, callbacks?.account)),
-    draft: buildMutatorMap(zeroMutatorSchemas.draft, createDraftMutators(authData, callbacks?.draft)),
-    thread: buildMutatorMap(zeroMutatorSchemas.thread, createThreadMutators(authData, callbacks?.thread)),
-    user: buildMutatorMap(zeroMutatorSchemas.user, createUserMutators(authData, callbacks?.user)),
+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,12 +1,132 @@
 import type { Transaction } from '@rocicorp/zero';
-import type * as v from 'valibot';
 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 type ThreadMutatorCallbacks = {
-    [K in keyof ZeroMutatorSchemas['thread']]?: (args: v.InferOutput<ZeroMutatorSchemas['thread'][K]['delta']>) => Promise<void>;
-};
 export declare const setSystemLabel: (tx: Transaction<MarcoZeroSchema>, threadId: string, targetSpecialUse: LabelSpecialUse) => Promise<void>;
-export declare const createThreadMutators: (_authData: AuthData | undefined, callbacks?: ThreadMutatorCallbacks) => 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;AACjD,OAAO,KAAK,KAAK,CAAC,MAAM,SAAS,CAAA;AAEjC,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;AAEhE,MAAM,MAAM,sBAAsB,GAAG;KAClC,CAAC,IAAI,MAAM,kBAAkB,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAC1C,IAAI,EAAE,CAAC,CAAC,WAAW,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,KAC1D,OAAO,CAAC,IAAI,CAAC;CACnB,CAAA;AAKD,eAAO,MAAM,cAAc,OACrB,WAAW,CAAC,eAAe,CAAC,YACtB,MAAM,oBACE,eAAe,KAChC,OAAO,CAAC,IAAI,CAyFd,CAAA;AAED,eAAO,MAAM,oBAAoB,cACpB,QAAQ,GAAG,SAAS,cACnB,sBAAsB,KACjC,UAAU,CAAC,kBAAkB,CAAC,QAAQ,CAAC,CA4PxC,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';
-const buildLabelIdList = (labelIds) => labelIds.length === 0 ? '' : ` ${[...new Set(labelIds)].join(' ')} `;
+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, callbacks) => ({
-    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,9 +137,8 @@ export const createThreadMutators = (_authData, callbacks) => ({
                 });
             }
         }
-        callbacks?.addLabel?.(args);
-    },
-    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();
@@ -147,9 +159,8 @@ export const createThreadMutators = (_authData, callbacks) => ({
                 }
             }
         }
-        callbacks?.delete?.(args);
-    },
-    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) {
@@ -193,34 +204,36 @@ export const createThreadMutators = (_authData, callbacks) => ({
                 ]);
             }
         }
-        callbacks?.removeLabel?.(args);
-    },
-    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');
             }
         }
-        callbacks?.setArchive?.(args);
-    },
-    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,
             })));
         }
-        callbacks?.setFlagged?.(args);
-    },
-    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');
             }
         }
-        callbacks?.setInbox?.(args);
-    },
-    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();
@@ -245,22 +258,19 @@ export const createThreadMutators = (_authData, callbacks) => ({
             id: threadId,
             seen: args.seen,
         })));
-        callbacks?.setSeen?.(args);
-    },
-    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');
             }
         }
-        callbacks?.setSpam?.(args);
-    },
-    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');
             }
         }
-        callbacks?.setTrash?.(args);
-    },
-});
+    }),
+};

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

@@ -1,8 +1,32 @@
-import type * as v from 'valibot';
-import type { AuthData, HandlerMap } from '../../../types';
-import type { ZeroMutatorSchemas } from '../../../zero/mutatorSchemas';
-export type UserMutatorCallbacks = {
-    [K in keyof ZeroMutatorSchemas['user']]?: (args: v.InferOutput<ZeroMutatorSchemas['user'][K]['delta']>) => Promise<void>;
+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>;
 };
-export declare const createUserMutators: (_authData: AuthData | undefined, callbacks?: UserMutatorCallbacks) => HandlerMap<ZeroMutatorSchemas["user"]>;
 //# 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,KAAK,CAAC,MAAM,SAAS,CAAA;AAEjC,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAC/D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAA;AAE3E,MAAM,MAAM,oBAAoB,GAAG;KAChC,CAAC,IAAI,MAAM,kBAAkB,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CACxC,IAAI,EAAE,CAAC,CAAC,WAAW,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,KACxD,OAAO,CAAC,IAAI,CAAC;CACnB,CAAA;AAED,eAAO,MAAM,kBAAkB,cAClB,QAAQ,GAAG,SAAS,cACnB,oBAAoB,KAC/B,UAAU,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAkCtC,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,18 +1,33 @@
-export const createUserMutators = (_authData, callbacks) => ({
-    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,
         });
-        callbacks?.deleteSettingsPushNotificationToken?.(args);
-    },
-    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,
         });
-        callbacks?.setSettingsName?.(args);
-    },
-    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)
@@ -25,7 +40,6 @@ export const createUserMutators = (_authData, callbacks) => ({
                 token: args.pushNotificationToken.token,
                 userId: args.id,
             });
-            callbacks?.setSettingsPushNotificationToken?.(args);
         }
-    },
-});
+    }),
+};