@marcoappio/marco-config 2.0.503 → 2.0.504

package/dist/zero/crud.d.ts

@@ -1,4 +1,4 @@
-export declare const zeroCRUD: import("node_modules/@rocicorp/zero/out/zql/src/mutate/crud").SchemaCRUDMutators<{
+export declare const zeroCRUD: import("@rocicorp/zero").SchemaCRUDMutators<{
     tables: {
         readonly user: {
             name: "user";

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;AAM5B,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,KAAK,CAAC,MAAM,SAAS,CAAA;AAO5B,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4CjC,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8H3B,CAAA"}

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

@@ -2,6 +2,7 @@ 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(),
@@ -80,10 +81,10 @@ export const accountMutators = {
         await tx.mutate(zeroCRUD.account.delete({ id }));
     }),
     deleteAlias: defineMutator(accountMutatorSchemas.deleteAlias, async ({ tx, args: { accountId, aliasId } }) => {
-        const alias = await tx.run(tx.query.accountAlias.where('id', aliasId).one());
+        const alias = await tx.run(z.accountAlias.where('id', aliasId).one());
         await tx.mutate(zeroCRUD.accountAlias.delete({ id: aliasId }));
         if (alias?.isPrimary) {
-            const remainingAliases = await tx.run(tx.query.accountAlias.where('accountId', accountId));
+            const remainingAliases = await tx.run(z.accountAlias.where('accountId', accountId));
             if (remainingAliases.length > 0) {
                 const newPrimaryAlias = remainingAliases[0];
                 await tx.mutate(zeroCRUD.accountAlias.update({
@@ -110,7 +111,7 @@ export const accountMutators = {
         }));
     }),
     setAliasPrimary: defineMutator(accountMutatorSchemas.setAliasPrimary, async ({ tx, args: { accountId, aliasId } }) => {
-        const aliases = await tx.run(tx.query.accountAlias.where('accountId', accountId));
+        const aliases = await tx.run(z.accountAlias.where('accountId', accountId));
         for (const alias of aliases) {
             await tx.mutate(zeroCRUD.accountAlias.update({
                 id: alias.id,

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

@@ -1 +1 @@
-{"version":3,"file":"draftMutators.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/draftMutators/draftMutators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAuD5B,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqC/B,CAAA;AAED,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyKzB,CAAA"}
+{"version":3,"file":"draftMutators.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/draftMutators/draftMutators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAwD5B,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqC/B,CAAA;AAED,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyKzB,CAAA"}

package/dist/zero/mutators/draftMutators/draftMutators.js

@@ -3,6 +3,7 @@ import { marcoSchemas } from '../../../schemas';
 import { DRAFT_ATTACHMENT_UPLOAD_STATUSES, DRAFT_STATUSES, DRAFT_TYPES, MutationError } from '../../../types';
 import { stringPatch } from '../../../utils';
 import { zeroCRUD } from '../../../zero/crud';
+import { z } from '../../../zero/queries/z';
 import { defineMutator } from '../typedMutator';
 const draftBodySchema = v.object({
     bcc: v.array(marcoSchemas.string.email()),
@@ -86,7 +87,7 @@ export const draftMutatorSchemas = {
 };
 export const draftMutators = {
     cancelSend: defineMutator(draftMutatorSchemas.cancelSend, async ({ tx, args: { id, updatedAt } }) => {
-        const draft = await tx.run(tx.query.draft.where('id', id).one());
+        const draft = await tx.run(z.draft.where('id', id).one());
         if (!draft) {
             throw new Error(MutationError.ENTITY_NOT_FOUND);
         }
@@ -172,7 +173,7 @@ export const draftMutators = {
         }
     }),
     setContent: defineMutator(draftMutatorSchemas.setContent, async ({ tx, args: { id, patch, updatedAt } }) => {
-        const draft = await tx.run(tx.query.draft.where('id', id).one());
+        const draft = await tx.run(z.draft.where('id', id).one());
         if (!draft) {
             throw new Error(MutationError.ENTITY_NOT_FOUND);
         }
@@ -186,7 +187,7 @@ export const draftMutators = {
         }));
     }),
     setEnvelope: defineMutator(draftMutatorSchemas.setEnvelope, async ({ tx, args: { id, envelope, updatedAt } }) => {
-        const draft = await tx.run(tx.query.draft.where('id', id).one());
+        const draft = await tx.run(z.draft.where('id', id).one());
         if (!draft) {
             throw new Error(MutationError.ENTITY_NOT_FOUND);
         }

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,CAAC,MAAM,SAAS,CAAA;AAG5B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAI1D,OAAO,EAAiB,KAAK,gBAAgB,EAAE,MAAM,0CAA0C,CAAA;AAoB/F,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBhC,CAAA;AAED,eAAO,MAAM,cAAc,OACrB,gBAAgB,YACV,MAAM,oBACE,eAAe,KAChC,OAAO,CAAC,IAAI,CAqGd,CAAA;AAED,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsQ1B,CAAA"}
+{"version":3,"file":"threadMutators.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/threadMutators/threadMutators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAG5B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAI1D,OAAO,EAAiB,KAAK,gBAAgB,EAAE,MAAM,0CAA0C,CAAA;AAqB/F,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgBhC,CAAA;AAED,eAAO,MAAM,cAAc,OACrB,gBAAgB,YACV,MAAM,oBACE,eAAe,KAChC,OAAO,CAAC,IAAI,CAqGd,CAAA;AAED,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoQ1B,CAAA"}

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

@@ -4,6 +4,7 @@ import { MutationError } from '../../../types';
 import { threadsUtils } from '../../../utils/threads';
 import { zeroCRUD } from '../../../zero/crud';
 import { defineMutator } from '../../../zero/mutators/typedMutator';
+import { z } from '../../../zero/queries/z';
 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()),
@@ -33,13 +34,13 @@ export const threadMutatorSchemas = {
     setTrash: baseThreadSchema,
 };
 export const setSystemLabel = async (tx, threadId, targetSpecialUse) => {
-    const thread = await tx.run(tx.query.thread.where('id', threadId).one());
+    const thread = await tx.run(z.thread.where('id', threadId).one());
     if (!thread) {
         throw new Error(MutationError.ENTITY_NOT_FOUND);
     }
     const [targetLabel, messages] = await Promise.all([
-        tx.run(tx.query.accountLabel.where('accountId', thread.accountId).where('specialUse', targetSpecialUse).one()),
-        tx.run(tx.query.threadMessage.where('threadId', threadId)),
+        tx.run(z.accountLabel.where('accountId', thread.accountId).where('specialUse', targetSpecialUse).one()),
+        tx.run(z.threadMessage.where('threadId', threadId)),
     ]);
     if (!targetLabel) {
         throw new Error(MutationError.ENTITY_NOT_FOUND);
@@ -63,7 +64,7 @@ export const setSystemLabel = async (tx, threadId, targetSpecialUse) => {
         ...[...labelIdsToRemove].map(labelId => tx.mutate(zeroCRUD.threadByLabel.delete({ labelId, threadId }))),
     ]);
     if (thread.seen === false && labelIdsToRemove.size > 0) {
-        const labelsToUpdate = await tx.run(tx.query.accountLabel.where('id', 'IN', [...labelIdsToRemove]));
+        const labelsToUpdate = await tx.run(z.accountLabel.where('id', 'IN', [...labelIdsToRemove]));
         await Promise.all(labelsToUpdate.map(label => tx.mutate(zeroCRUD.accountLabel.update({
             id: label.id,
             unreadCount: Math.max(0, (label.unreadCount ?? 0) - 1),
@@ -104,14 +105,14 @@ export const setSystemLabel = async (tx, threadId, targetSpecialUse) => {
 export const threadMutators = {
     addLabel: defineMutator(threadMutatorSchemas.addLabel, async ({ tx, args: { accounts, labelPath } }) => {
         for (const [accountId, { threadIds }] of Object.entries(accounts)) {
-            const label = await tx.run(tx.query.accountLabel.where('accountId', accountId).where('path', labelPath).one());
+            const label = await tx.run(z.accountLabel.where('accountId', accountId).where('path', labelPath).one());
             if (!label) {
                 throw new Error(MutationError.ENTITY_NOT_FOUND);
             }
             for (const threadId of threadIds) {
                 const [thread, messages] = await Promise.all([
-                    tx.run(tx.query.thread.where('id', threadId).one()),
-                    tx.run(tx.query.threadMessage.where('threadId', threadId)),
+                    tx.run(z.thread.where('id', threadId).one()),
+                    tx.run(z.threadMessage.where('threadId', threadId)),
                 ]);
                 if (!thread) {
                     throw new Error(MutationError.ENTITY_NOT_FOUND);
@@ -134,7 +135,7 @@ export const threadMutators = {
                             : []),
                     ]);
                 }
-                const existingChecks = await Promise.all(messages.map(x => tx.run(tx.query.threadLabel.where('threadMessageId', x.id).where('labelId', label.id).one())));
+                const existingChecks = await Promise.all(messages.map(x => tx.run(z.threadLabel.where('threadMessageId', x.id).where('labelId', label.id).one())));
                 const messagesToInsert = messages.filter((_, i) => !existingChecks[i]);
                 const baseTimestamp = Date.now();
                 if (messagesToInsert.length > 0) {
@@ -159,12 +160,12 @@ export const threadMutators = {
     delete: defineMutator(threadMutatorSchemas.delete, async ({ tx, args: { accounts } }) => {
         for (const [, { threadIds }] of Object.entries(accounts)) {
             for (const threadId of threadIds) {
-                const thread = await tx.run(tx.query.thread.where('id', threadId).one());
+                const thread = await tx.run(z.thread.where('id', threadId).one());
                 if (thread) {
                     if (thread.seen === false) {
                         const labelIds = threadsUtils.parseLabelIdList(thread.labelIdList);
                         if (labelIds.length > 0) {
-                            const labels = await tx.run(tx.query.accountLabel.where('id', 'IN', labelIds));
+                            const labels = await tx.run(z.accountLabel.where('id', 'IN', labelIds));
                             await Promise.all(labels.map(x => tx.mutate(zeroCRUD.accountLabel.update({
                                 id: x.id,
                                 unreadCount: Math.max(0, (x.unreadCount ?? 0) - 1),
@@ -180,14 +181,14 @@ export const threadMutators = {
     }),
     removeLabel: defineMutator(threadMutatorSchemas.removeLabel, async ({ tx, args: { accounts, labelPath } }) => {
         for (const [accountId, { threadIds }] of Object.entries(accounts)) {
-            const label = await tx.run(tx.query.accountLabel.where('accountId', accountId).where('path', labelPath).one());
+            const label = await tx.run(z.accountLabel.where('accountId', accountId).where('path', labelPath).one());
             if (!label) {
                 throw new Error(MutationError.ENTITY_NOT_FOUND);
             }
             for (const threadId of threadIds) {
                 const [thread, messages] = await Promise.all([
-                    tx.run(tx.query.thread.where('id', threadId).one()),
-                    tx.run(tx.query.threadMessage.where('threadId', threadId)),
+                    tx.run(z.thread.where('id', threadId).one()),
+                    tx.run(z.threadMessage.where('threadId', threadId)),
                 ]);
                 if (!thread) {
                     throw new Error(MutationError.ENTITY_NOT_FOUND);
@@ -247,7 +248,7 @@ export const threadMutators = {
     }),
     setSeen: defineMutator(threadMutatorSchemas.setSeen, async ({ tx, args: { accounts, seen } }) => {
         const allThreadIds = Object.values(accounts).flatMap(x => x.threadIds);
-        const threads = await tx.run(tx.query.thread.where('id', 'IN', allThreadIds));
+        const threads = await tx.run(z.thread.where('id', 'IN', allThreadIds));
         const labelCounts = new Map();
         for (const thread of threads) {
             if (thread.seen !== seen) {
@@ -257,7 +258,7 @@ export const threadMutators = {
             }
         }
         if (labelCounts.size > 0) {
-            const labels = await tx.run(tx.query.accountLabel.where('id', 'IN', [...labelCounts.keys()]));
+            const labels = await tx.run(z.accountLabel.where('id', 'IN', [...labelCounts.keys()]));
             const delta = seen ? -1 : 1;
             await Promise.all(labels
                 .filter(x => labelCounts.has(x.id))

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,CAAC,MAAM,SAAS,CAAA;AAM5B,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;CAiB9B,CAAA;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BxB,CAAA"}
+{"version":3,"file":"userMutators.d.ts","sourceRoot":"","sources":["../../../../src/zero/mutators/userMutators/userMutators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAO5B,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;CAiB9B,CAAA;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BxB,CAAA"}

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

@@ -2,6 +2,7 @@ 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 userMutatorSchemas = {
     deleteSettingsPushNotificationToken: v.object({
         id: marcoSchemas.string.required(),
@@ -28,7 +29,7 @@ export const userMutators = {
         await tx.mutate(zeroCRUD.user.update({ id, name }));
     }),
     setSettingsPushNotificationToken: defineMutator(userMutatorSchemas.setSettingsPushNotificationToken, async ({ tx, args: { id, pushNotificationToken } }) => {
-        const existing = await tx.run(tx.query.userPushNotificationToken.where('userId', id).where('token', pushNotificationToken.token).one());
+        const existing = await tx.run(z.userPushNotificationToken.where('userId', id).where('token', pushNotificationToken.token).one());
         if (!existing) {
             await tx.mutate(zeroCRUD.userPushNotificationToken.insert({
                 createdAt: pushNotificationToken.createdAt,

package/dist/zero/queries/getAccounts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getAccounts.d.ts","sourceRoot":"","sources":["../../../src/zero/queries/getAccounts.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEvB,CAAA"}
+{"version":3,"file":"getAccounts.d.ts","sourceRoot":"","sources":["../../../src/zero/queries/getAccounts.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAItB,CAAA"}

package/dist/zero/queries/getAccounts.js

@@ -1,3 +1,6 @@
 import { defineQuery } from '@rocicorp/zero';
 import { z } from '../../zero/queries/z';
-export const getAccounts = defineQuery(({ ctx: { userId } }) => z.account.where('userId', userId).related('aliases').related('primaryAlias').related('labels'));
+export const getAccounts = defineQuery(({ ctx: { userId } }) => {
+    console.log('CONTEXT_USER_ID', userId);
+    return z.account.where('userId', userId).related('aliases').related('primaryAlias').related('labels');
+});

package/dist/zero/queries/getUser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getUser.d.ts","sourceRoot":"","sources":["../../../src/zero/queries/getUser.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMnB,CAAA"}
+{"version":3,"file":"getUser.d.ts","sourceRoot":"","sources":["../../../src/zero/queries/getUser.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOlB,CAAA"}

package/dist/zero/queries/getUser.js

@@ -1,7 +1,10 @@
 import { defineQuery } from '@rocicorp/zero';
 import { z } from '../../zero/queries/z';
-export const getUser = defineQuery(({ ctx: { userId } }) => z.user
-    .where('id', userId)
-    .limit(1)
-    .related('accounts', x => x.related('aliases').related('primaryAlias').related('labels'))
-    .related('pushNotificationTokens'));
+export const getUser = defineQuery(({ ctx: { userId } }) => {
+    console.log('CONTEXT_USER_ID', userId);
+    return z.user
+        .where('id', userId)
+        .limit(1)
+        .related('accounts', x => x.related('aliases').related('primaryAlias').related('labels'))
+        .related('pushNotificationTokens');
+});