@zenstackhq/sdk 3.0.0-alpha.6 → 3.0.0-alpha.7

package/dist/index.cjs

@@ -933,7 +933,7 @@ var TsSchemaGenerator = class {
   }
   createDataModelFieldObject(field) {
     const objectFields = [
-      ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(field.type.type ?? field.type.reference.$refText))
+      ts.factory.createPropertyAssignment("type", this.generateFieldTypeLiteral(field))
     ];
     if (isIdField(field)) {
       objectFields.push(ts.factory.createPropertyAssignment("id", ts.factory.createTrue()));
@@ -953,9 +953,9 @@ var TsSchemaGenerator = class {
     if (field.attributes.length > 0) {
       objectFields.push(ts.factory.createPropertyAssignment("attributes", ts.factory.createArrayLiteralExpression(field.attributes.map((attr) => this.createAttributeObject(attr)))));
     }
-    const defaultValue = this.getMappedDefault(field);
+    const defaultValue = this.getFieldMappedDefault(field);
     if (defaultValue !== void 0) {
-      if (typeof defaultValue === "object") {
+      if (typeof defaultValue === "object" && !Array.isArray(defaultValue)) {
         if ("call" in defaultValue) {
           objectFields.push(ts.factory.createPropertyAssignment("default", ts.factory.createCallExpression(ts.factory.createIdentifier("ExpressionUtils.call"), void 0, [
             ts.factory.createStringLiteral(defaultValue.call),
@@ -974,7 +974,11 @@ var TsSchemaGenerator = class {
           throw new Error(`Unsupported default value type for field ${field.name}`);
         }
       } else {
-        objectFields.push(ts.factory.createPropertyAssignment("default", typeof defaultValue === "string" ? ts.factory.createStringLiteral(defaultValue) : typeof defaultValue === "number" ? ts.factory.createNumericLiteral(defaultValue) : defaultValue === true ? ts.factory.createTrue() : ts.factory.createFalse()));
+        if (Array.isArray(defaultValue)) {
+          objectFields.push(ts.factory.createPropertyAssignment("default", ts.factory.createArrayLiteralExpression(defaultValue.map((item) => this.createLiteralNode(item)))));
+        } else {
+          objectFields.push(ts.factory.createPropertyAssignment("default", this.createLiteralNode(defaultValue)));
+        }
       }
     }
     if (hasAttribute(field, "@computed")) {
@@ -1015,34 +1019,39 @@ var TsSchemaGenerator = class {
       throw new Error("Unsupported URL type");
     }
   }
-  getMappedDefault(field) {
+  getFieldMappedDefault(field) {
     const defaultAttr = getAttribute(field, "@default");
     if (!defaultAttr) {
       return void 0;
     }
     const defaultValue = defaultAttr.args[0]?.value;
     (0, import_common_helpers.invariant)(defaultValue, "Expected a default value");
-    if ((0, import_ast3.isLiteralExpr)(defaultValue)) {
-      const lit = defaultValue.value;
-      return field.type.type === "Boolean" ? lit : [
+    return this.getMappedValue(defaultValue, field.type);
+  }
+  getMappedValue(expr, fieldType) {
+    if ((0, import_ast3.isLiteralExpr)(expr)) {
+      const lit = expr.value;
+      return fieldType.type === "Boolean" ? lit : [
         "Int",
         "Float",
         "Decimal",
         "BigInt"
-      ].includes(field.type.type) ? Number(lit) : lit;
-    } else if ((0, import_ast3.isReferenceExpr)(defaultValue) && (0, import_ast3.isEnumField)(defaultValue.target.ref)) {
-      return defaultValue.target.ref.name;
-    } else if ((0, import_ast3.isInvocationExpr)(defaultValue)) {
+      ].includes(fieldType.type) ? Number(lit) : lit;
+    } else if ((0, import_ast3.isArrayExpr)(expr)) {
+      return expr.items.map((item) => this.getMappedValue(item, fieldType));
+    } else if ((0, import_ast3.isReferenceExpr)(expr) && (0, import_ast3.isEnumField)(expr.target.ref)) {
+      return expr.target.ref.name;
+    } else if ((0, import_ast3.isInvocationExpr)(expr)) {
       return {
-        call: defaultValue.function.$refText,
-        args: defaultValue.args.map((arg) => this.getLiteral(arg.value))
+        call: expr.function.$refText,
+        args: expr.args.map((arg) => this.getLiteral(arg.value))
       };
-    } else if (this.isAuthMemberAccess(defaultValue)) {
+    } else if (this.isAuthMemberAccess(expr)) {
       return {
-        authMember: this.getMemberAccessChain(defaultValue)
+        authMember: this.getMemberAccessChain(expr)
       };
     } else {
-      throw new Error(`Unsupported default value type for field ${field.name}`);
+      throw new Error(`Unsupported default value type for ${expr.$type}`);
     }
   }
   getMemberAccessChain(expr) {
@@ -1155,10 +1164,11 @@ var TsSchemaGenerator = class {
     for (const field of dm.fields) {
       if (hasAttribute(field, "@id") || hasAttribute(field, "@unique")) {
         properties.push(ts.factory.createPropertyAssignment(field.name, ts.factory.createObjectLiteralExpression([
-          ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(field.type.type))
+          ts.factory.createPropertyAssignment("type", this.generateFieldTypeLiteral(field))
         ])));
       }
     }
+    const seenKeys = /* @__PURE__ */ new Set();
     for (const attr of dm.attributes) {
       if (attr.decl.$refText === "@@id" || attr.decl.$refText === "@@unique") {
         const fieldNames = this.getReferenceNames(attr.args[0].value);
@@ -1168,13 +1178,18 @@ var TsSchemaGenerator = class {
         if (fieldNames.length === 1) {
           const fieldDef = dm.fields.find((f) => f.name === fieldNames[0]);
           properties.push(ts.factory.createPropertyAssignment(fieldNames[0], ts.factory.createObjectLiteralExpression([
-            ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(fieldDef.type.type))
+            ts.factory.createPropertyAssignment("type", this.generateFieldTypeLiteral(fieldDef))
           ])));
         } else {
+          const key = fieldNames.join("_");
+          if (seenKeys.has(key)) {
+            continue;
+          }
+          seenKeys.add(key);
           properties.push(ts.factory.createPropertyAssignment(fieldNames.join("_"), ts.factory.createObjectLiteralExpression(fieldNames.map((field) => {
             const fieldDef = dm.fields.find((f) => f.name === field);
             return ts.factory.createPropertyAssignment(field, ts.factory.createObjectLiteralExpression([
-              ts.factory.createPropertyAssignment("type", ts.factory.createStringLiteral(fieldDef.type.type))
+              ts.factory.createPropertyAssignment("type", this.generateFieldTypeLiteral(fieldDef))
             ]));
           }))));
         }
@@ -1182,6 +1197,10 @@ var TsSchemaGenerator = class {
     }
     return ts.factory.createObjectLiteralExpression(properties, true);
   }
+  generateFieldTypeLiteral(field) {
+    (0, import_common_helpers.invariant)(field.type.type || field.type.reference || field.type.unsupported, "Field type must be a primitive, reference, or Unsupported");
+    return field.type.type ? ts.factory.createStringLiteral(field.type.type) : field.type.reference ? ts.factory.createStringLiteral(field.type.reference.$refText) : ts.factory.createStringLiteral("unknown");
+  }
   createEnumObject(e) {
     return ts.factory.createObjectLiteralExpression(e.fields.map((field) => ts.factory.createPropertyAssignment(field.name, ts.factory.createStringLiteral(field.name))), true);
   }