jazz-tools 0.14.16 → 0.14.18

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> jazz-tools@0.14.16 build /home/runner/_work/jazz/jazz/packages/jazz-tools
+> jazz-tools@0.14.18 build /home/runner/_work/jazz/jazz/packages/jazz-tools
 > tsup && pnpm types
 
 CLI Building entry: {"index":"src/index.ts","testing":"src/testing.ts"}
@@ -11,12 +11,12 @@
 ESM Build start
 ESM dist/index.js              11.11 KB
 ESM dist/testing.js            6.31 KB
-ESM dist/chunk-GRIN3FQP.js     133.77 KB
+ESM dist/chunk-AA3SCYKI.js     133.47 KB
 ESM dist/index.js.map          18.38 KB
 ESM dist/testing.js.map        12.57 KB
-ESM dist/chunk-GRIN3FQP.js.map 309.59 KB
-ESM ⚡️ Build success in 53ms
+ESM dist/chunk-AA3SCYKI.js.map 308.05 KB
+ESM ⚡️ Build success in 56ms
 
-> jazz-tools@0.14.16 types /home/runner/_work/jazz/jazz/packages/jazz-tools
+> jazz-tools@0.14.18 types /home/runner/_work/jazz/jazz/packages/jazz-tools
 > tsc --outDir dist
 

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # jazz-tools
 
+## 0.14.18
+
+### Patch Changes
+
+- 4b950bc: Fixes support for recursive props on co.profile and for co.image inside z.discriminatedUnion
+- d6d9c0a: Make checks on the discriminator field on z.discriminatedUnion more specific and less strict
+- c559054: Add support for optional dates
+- Updated dependencies [0d5ee3e]
+  - cojson@0.14.18
+
+## 0.14.17
+
+### Patch Changes
+
+- e512df4: Move to latest stable version of Zod
+
 ## 0.14.16
 
 ### Patch Changes

package/dist/{chunk-GRIN3FQP.js → chunk-AA3SCYKI.js}

@@ -3446,32 +3446,37 @@ function getDef(schema) {
 }
 
 // src/implementation/zodSchema/zodCo.ts
+function enrichCoMapSchema(schema) {
+  const baseCatchall = schema.catchall;
+  const enrichedSchema = Object.assign(schema, {
+    collaborative: true,
+    create: (...args) => {
+      return coSchema.create(...args);
+    },
+    load: (...args) => {
+      return coSchema.load(...args);
+    },
+    subscribe: (...args) => {
+      return coSchema.subscribe(...args);
+    },
+    findUnique: (...args) => {
+      return coSchema.findUnique(...args);
+    },
+    catchall: (index) => {
+      return enrichCoMapSchema(baseCatchall(index));
+    },
+    withHelpers: (helpers) => {
+      return Object.assign(schema, helpers(schema));
+    }
+  });
+  const coSchema = zodSchemaToCoSchema2(enrichedSchema);
+  return enrichedSchema;
+}
 var coMapDefiner = (shape) => {
   const objectSchema = z.object(shape).meta({
     collaborative: true
   });
-  const coMapSchema = objectSchema;
-  coMapSchema.collaborative = true;
-  coMapSchema.create = function(...args) {
-    return zodSchemaToCoSchema2(this).create(...args);
-  };
-  coMapSchema.load = function(...args) {
-    return zodSchemaToCoSchema2(this).load(...args);
-  };
-  coMapSchema.subscribe = function(...args) {
-    return zodSchemaToCoSchema2(this).subscribe(...args);
-  };
-  coMapSchema.findUnique = function(unique, ownerID, as) {
-    return zodSchemaToCoSchema2(this).findUnique(unique, ownerID, as);
-  };
-  const oldCatchall = coMapSchema.catchall;
-  coMapSchema.catchall = function(schema) {
-    return { ...this, ...oldCatchall(schema) };
-  };
-  coMapSchema.withHelpers = function(helpers) {
-    return { ...this, ...helpers(this) };
-  };
-  return coMapSchema;
+  return enrichCoMapSchema(objectSchema);
 };
 var coAccountDefiner = (shape = {
   profile: coMapDefiner({
@@ -3506,7 +3511,7 @@ var coAccountDefiner = (shape = {
     return { ...this, ...helpers };
   };
   accountSchema.withMigration = function(migration) {
-    return { ...this, migration };
+    return Object.assign(this, { migration });
   };
   return accountSchema;
 };
@@ -3529,24 +3534,17 @@ var coListDefiner = (element) => {
     return zodSchemaToCoSchema2(this).subscribe(...args);
   };
   coListSchema.withHelpers = function(helpers) {
-    return { ...this, ...helpers(this) };
+    return Object.assign(this, helpers(this));
   };
   return coListSchema;
 };
 var coProfileDefiner = (shape = {}) => {
-  const base = coMapDefiner({
-    ...shape ?? {},
+  const ehnancedShape = Object.assign(shape ?? {}, {
     name: z.string(),
     inbox: z.optional(z.string()),
     inboxInvite: z.optional(z.string())
   });
-  return {
-    ...base,
-    // enforce that the owner is a group
-    create: (init, options) => {
-      return base.create(init, options);
-    }
-  };
+  return coMapDefiner(ehnancedShape);
 };
 var coFeedDefiner = (element) => {
   const placeholderSchema = z.instanceof(CoFeed);
@@ -3650,70 +3648,69 @@ function schemaUnionDiscriminatorFor(schema) {
         "z.union() of collaborative types is not supported, use z.discriminatedUnion() instead"
       );
     }
-    if (![...schema._zod.disc.keys()].every((key) => typeof key === "string")) {
+    const discriminator = schema._zod.def.discriminator;
+    const field = schema._zod.disc.get(discriminator);
+    if (!field) {
       throw new Error(
-        "z.discriminatedUnion() of collaborative types with non-string discriminator key is not supported"
+        "z.discriminatedUnion() of collaborative types with non-existent discriminator key is not supported"
       );
     }
-    if (![...schema._zod.disc.values()].every(
-      (v) => [...v.values].every((value) => typeof value === "string")
-    )) {
-      throw new Error(
-        "z.discriminatedUnion() of collaborative types with non-string discriminator value is not supported"
-      );
+    for (const value of field.values) {
+      if (typeof value !== "string" && typeof value !== "number") {
+        throw new Error(
+          "z.discriminatedUnion() of collaborative types with non-string or non-number discriminator value is not supported"
+        );
+      }
     }
-    const flattendOptions = [
-      ...schema._zod.def.options.flatMap((option) => {
-        if (option._zod.def.type === "object") {
-          return [option];
-        } else if (option._zod.def.type === "union") {
-          return [...option._zod.def.options];
-        } else {
-          throw new Error(
-            "Unsupported zod type in z.discriminatedUnion() of collaborative types"
-          );
+    const availableOptions = [];
+    for (const option of schema._zod.def.options) {
+      if (option._zod.def.type === "object") {
+        availableOptions.push(option);
+      } else if (option._zod.def.type === "union") {
+        for (const subOption of option._zod.def.options) {
+          if (subOption._zod.def.type === "object") {
+            availableOptions.push(subOption);
+          }
         }
-      })
-    ];
+      } else {
+        throw new Error(
+          "Unsupported zod type in z.discriminatedUnion() of collaborative types"
+        );
+      }
+    }
     const determineSchema = (_raw) => {
       if (_raw instanceof RawCoList) {
         throw new Error(
           "z.discriminatedUnion() of collaborative types is not supported for CoLists"
         );
       }
-      let remainingOptions = [...flattendOptions];
-      for (const discriminator of schema._zod.disc.keys()) {
-        const discriminatorValue = _raw.get(
-          discriminator
-        );
-        if (typeof discriminatorValue !== "string") {
-          throw new Error("Discriminator must be a string");
-        }
-        remainingOptions = remainingOptions.filter((option) => {
-          if (option._zod.def.type !== "object") {
-            return false;
+      for (const option of availableOptions) {
+        let match = true;
+        for (const key of schema._zod.disc.keys()) {
+          const discriminatorDef = option._zod.def.shape[key];
+          const discriminatorValue = _raw.get(key);
+          if (discriminatorValue && typeof discriminatorValue === "object") {
+            throw new Error("Discriminator must be a primitive value");
           }
-          const discriminatorDef = option._zod.def.shape[discriminator];
           if (!discriminatorDef) {
-            return false;
+            if (key === discriminator) {
+              match = false;
+              break;
+            } else {
+              continue;
+            }
           }
-          console.log(discriminatorDef._zod.def);
           if (discriminatorDef._zod.def.type !== "literal") {
-            console.warn(
-              "Non-literal discriminator found in z.discriminatedUnion() of collaborative types"
-            );
-            return false;
+            break;
           }
-          if (discriminatorDef._zod.def.values.length !== 1) {
-            console.warn(
-              "Literal discriminator with more than one value found in z.discriminatedUnion() of collaborative types"
-            );
-            return false;
+          const literalDef = discriminatorDef._zod.def;
+          if (!Array.from(literalDef.values).includes(discriminatorValue)) {
+            match = false;
+            break;
           }
-          return discriminatorDef._zod.def.values[0] === discriminatorValue;
-        });
-        if (remainingOptions.length === 1) {
-          return zodSchemaToCoSchema2(remainingOptions[0]);
+        }
+        if (match) {
+          return zodSchemaToCoSchema2(option);
         }
       }
       throw new Error(
@@ -3781,7 +3778,7 @@ function zodFieldToCoFieldDef(schema) {
           schema.def.innerType
         );
       } else if (schema._zod.def.type === "date") {
-        return coField.Date;
+        return coField.optional.Date;
       } else if (schema._zod.def.type === "template_literal") {
         return coField.string;
       } else if (schema._zod.def.type === "lazy") {
@@ -4675,4 +4672,4 @@ export {
   JazzContextManager
 };
 /* istanbul ignore file -- @preserve */
-//# sourceMappingURL=chunk-GRIN3FQP.js.map
+//# sourceMappingURL=chunk-AA3SCYKI.js.map