@pylo/node 0.0.6 → 0.0.8

package/dist/cli.js

@@ -76,6 +76,11 @@ query PyloSchemaFetch($pagination: PaginationInput) {
               name
             }
           }
+          entity_field_enum_values {
+            data {
+              value
+            }
+          }
         }
       }
       entity_relations {
@@ -185,14 +190,30 @@ function getMutationSuffixes(relType) {
 function toEntityKey(pascalName) {
   return pascalName.charAt(0).toLowerCase() + pascalName.slice(1);
 }
-function analyzeField(field) {
-  var _a, _b;
+function toPascalCase(snake) {
+  return snake.split("_").filter((part) => part.length > 0).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function analyzeField(field, entityPascalName) {
+  var _a, _b, _c, _d;
   const hasVariants = ((_b = (_a = field.variant_entity_field) == null ? void 0 : _a.data) == null ? void 0 : _b.name) != null;
+  const enumValues = (_d = (_c = field.entity_field_enum_values) == null ? void 0 : _c.data) != null ? _d : [];
+  if (enumValues.length > 0) {
+    const typeName = `${entityPascalName}${toPascalCase(field.name)}`;
+    const values = enumValues.map((v) => v.value);
+    return {
+      name: field.name,
+      tsType: typeName,
+      nullable: isNullable(field),
+      variantFieldName: hasVariants ? `${field.name}_variants` : null,
+      enum: { typeName, values }
+    };
+  }
   return {
     name: field.name,
     tsType: mapDataType(field.data_type),
     nullable: isNullable(field),
-    variantFieldName: hasVariants ? `${field.name}_variants` : null
+    variantFieldName: hasVariants ? `${field.name}_variants` : null,
+    enum: null
   };
 }
 function analyzeRelation(relation) {
@@ -224,7 +245,9 @@ function analyzeReverseRelation(relation) {
 function analyzeEntities(rawEntities) {
   return rawEntities.map((entity) => {
     var _a, _b, _c, _d, _e, _f;
-    const fields = ((_b = (_a = entity.entity_fields) == null ? void 0 : _a.data) != null ? _b : []).map(analyzeField);
+    const fields = ((_b = (_a = entity.entity_fields) == null ? void 0 : _a.data) != null ? _b : []).map(
+      (f) => analyzeField(f, entity.name)
+    );
     const forwardRelations = ((_d = (_c = entity.entity_relations) == null ? void 0 : _c.data) != null ? _d : []).map(analyzeRelation).filter((r) => r !== null);
     const reverseRelations = ((_f = (_e = entity.entity_related) == null ? void 0 : _e.data) != null ? _f : []).map(analyzeReverseRelation).filter((r) => r !== null);
     const seen = new Set(forwardRelations.map((r) => r.fieldName));
@@ -281,8 +304,9 @@ function generateCreateInputType(entity) {
   }
   for (const rel of entity.relations) {
     for (const suffix of rel.suffixes) {
+      const valueType = rel.type === "hasMany" ? "Record<string, unknown>[]" : "Record<string, unknown>";
       lines.push(
-        `${rel.fieldName}${suffix}?: Record<string, unknown>;`
+        `${rel.fieldName}${suffix}?: ${valueType};`
       );
     }
   }
@@ -304,13 +328,25 @@ function generateUpdateInputType(entity) {
   }
   for (const rel of entity.relations) {
     for (const suffix of rel.suffixes) {
+      const valueType = rel.type === "hasMany" ? "Record<string, unknown>[]" : "Record<string, unknown>";
       lines.push(
-        `${rel.fieldName}${suffix}?: Record<string, unknown>;`
+        `${rel.fieldName}${suffix}?: ${valueType};`
       );
     }
   }
   return lines.join("\n");
 }
+function collectEnumTypes(entities) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const entity of entities) {
+    for (const field of entity.fields) {
+      if (field.enum && !seen.has(field.enum.typeName)) {
+        seen.set(field.enum.typeName, field.enum.values);
+      }
+    }
+  }
+  return Array.from(seen, ([typeName, values]) => ({ typeName, values }));
+}
 function generateIndexFile(entities, importSource) {
   const lines = [];
   lines.push(
@@ -331,6 +367,14 @@ function generateIndexFile(entities, importSource) {
     `} from '${importSource}';`,
     ""
   );
+  const enumTypes = collectEnumTypes(entities);
+  if (enumTypes.length > 0) {
+    for (const { typeName, values } of enumTypes) {
+      const union = values.map((v) => `'${v}'`).join(" | ");
+      lines.push(`export type ${typeName} = ${union};`);
+    }
+    lines.push("");
+  }
   for (const entity of entities) {
     lines.push(`export interface Create${entity.pascalName}Input {`);
     lines.push(indent(generateCreateInputType(entity), 1));
@@ -406,6 +450,15 @@ function generateSchemaMetadataFile(entities, unknownFieldBehavior, importSource
       const variantNamesStr = variantNames.map((n) => `'${n}'`).join(", ");
       lines.push(`      variantFieldNames: [${variantNamesStr}],`);
     }
+    const enumFields = entity.fields.filter((f) => f.enum !== null);
+    if (enumFields.length > 0) {
+      lines.push("      enumFields: {");
+      for (const f of enumFields) {
+        const vals = f.enum.values.map((v) => `'${v}'`).join(", ");
+        lines.push(`        ${f.name}: [${vals}],`);
+      }
+      lines.push("      },");
+    }
     lines.push("      relations: {");
     for (const rel of entity.relations) {
       lines.push(

package/dist/index.d.ts

@@ -42,6 +42,7 @@ interface EntityMetadata {
     pascalName: string;
     scalarFieldNames: string[];
     variantFieldNames?: string[];
+    enumFields?: Record<string, string[]>;
     relations: Record<string, {
         type: "hasOne" | "hasMany";
         entity: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pylo/node",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "Server-side Pylo SDK with API key authentication",
   "exports": {
     ".": {
@@ -28,7 +28,7 @@
     "@types/node": "^22.15.21",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
-    "@pylo/core": "0.0.8",
+    "@pylo/core": "0.0.10",
     "@pylo/auth": "0.0.4"
   },
   "license": "ISC",