@pylo/node 0.0.11 → 0.1.0

package/dist/schema.js

@@ -0,0 +1,406 @@
+// ../core/dist/schema.js
+var ENTITY_LIST_QUERY = `
+query PyloSchemaFetch($pagination: PaginationInput) {
+  entityList(pagination: $pagination) {
+    data {
+      name
+      shortcode
+      is_system_entity
+      entity_fields {
+        data {
+          name
+          data_type
+          validation_string
+          form_type
+          default_value
+          variant_entity_field {
+            data {
+              name
+            }
+          }
+          entity_field_enum_values {
+            data {
+              value
+            }
+          }
+        }
+      }
+      entity_relations {
+        data {
+          type
+          field_name
+          target_field_name
+          target_entity {
+            data {
+              name
+            }
+          }
+          entity_is_tightly_coupled
+          target_entity_is_tightly_coupled
+          allow_connect_create
+          allow_connect_existing
+        }
+      }
+      entity_related {
+        data {
+          type
+          field_name
+          target_field_name
+          entity {
+            data {
+              name
+            }
+          }
+          entity_is_tightly_coupled
+          target_entity_is_tightly_coupled
+          allow_connect_create
+          allow_connect_existing
+        }
+      }
+    }
+    pagination {
+      total
+      has_more_pages
+      current_page
+    }
+  }
+}
+`;
+async function fetchSchemaWith(request) {
+  var _a, _b;
+  const allEntities = [];
+  let page = 1;
+  let hasMore = true;
+  while (hasMore) {
+    const response = await request(ENTITY_LIST_QUERY, {
+      pagination: { page, per_page: 50 }
+    });
+    if (response.errors) {
+      const errMsg = Array.isArray(response.errors) ? response.errors.map((e) => e.message).join(", ") : (_b = (_a = response.errors.generalError) == null ? void 0 : _a.message) != null ? _b : "Unknown error";
+      throw new Error(`Failed to fetch schema: ${errMsg}`);
+    }
+    if (!response.data) {
+      throw new Error("No data returned from schema fetch");
+    }
+    const { data, pagination } = response.data.entityList;
+    allEntities.push(...data);
+    hasMore = pagination.has_more_pages;
+    page++;
+  }
+  return allEntities;
+}
+var DATA_TYPE_MAP = {
+  TEXT: "string",
+  LONGTEXT: "string",
+  RICHTEXT: "string",
+  INT: "number",
+  FLOAT: "number",
+  JSON: "Record<string, unknown> | unknown[]",
+  DATE: "string",
+  DATETIME: "string",
+  TIME: "string",
+  BOOLEAN: "boolean"
+};
+function mapDataType(dataType) {
+  var _a;
+  return (_a = DATA_TYPE_MAP[dataType]) != null ? _a : "string";
+}
+function isNullable(field) {
+  return field.validation_string !== "required";
+}
+function classifyRelation(relationType) {
+  if (relationType === "ManyToOne" || relationType === "OneToOne") {
+    return "hasOne";
+  }
+  return "hasMany";
+}
+function classifyReverseRelation(relationType) {
+  if (relationType === "OneToMany" || relationType === "OneToOne") {
+    return "hasOne";
+  }
+  return "hasMany";
+}
+function getMutationSuffixes(relType) {
+  if (relType === "hasOne") {
+    return ["_set"];
+  }
+  return ["_set", "_connect", "_disconnect"];
+}
+function toEntityKey(pascalName) {
+  return pascalName.charAt(0).toLowerCase() + pascalName.slice(1);
+}
+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,
+    enum: null
+  };
+}
+function analyzeRelation(relation) {
+  var _a, _b;
+  const targetName = (_b = (_a = relation.target_entity) == null ? void 0 : _a.data) == null ? void 0 : _b.name;
+  if (!targetName || !relation.field_name) return null;
+  const relType = classifyRelation(relation.type);
+  return {
+    fieldName: relation.field_name,
+    type: relType,
+    targetEntityKey: toEntityKey(targetName),
+    targetEntityPascalName: targetName,
+    suffixes: getMutationSuffixes(relType)
+  };
+}
+function analyzeReverseRelation(relation) {
+  var _a, _b;
+  const sourceName = (_b = (_a = relation.entity) == null ? void 0 : _a.data) == null ? void 0 : _b.name;
+  if (!sourceName || !relation.target_field_name) return null;
+  const relType = classifyReverseRelation(relation.type);
+  return {
+    fieldName: relation.target_field_name,
+    type: relType,
+    targetEntityKey: toEntityKey(sourceName),
+    targetEntityPascalName: sourceName,
+    suffixes: getMutationSuffixes(relType)
+  };
+}
+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(
+      (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));
+    const deduped = reverseRelations.filter((r) => !seen.has(r.fieldName));
+    return {
+      key: toEntityKey(entity.name),
+      pascalName: entity.name,
+      shortcode: entity.shortcode,
+      isSystem: entity.is_system_entity,
+      fields,
+      relations: [...forwardRelations, ...deduped]
+    };
+  });
+}
+var VARIANT_TYPE = "{ variant: string; value: string }";
+var REGISTERABLE_SOURCES = /* @__PURE__ */ new Set(["@pylo/node", "@pylo/nextjs"]);
+function fieldTypeString(field) {
+  if (field.nullable) {
+    return `${field.tsType} | null`;
+  }
+  return field.tsType;
+}
+function indent(text, level) {
+  const spaces = "  ".repeat(level);
+  return text.split("\n").map((line) => line.trim() ? spaces + line : line).join("\n");
+}
+function getVariantFieldNames(entity) {
+  return entity.fields.filter((f) => f.variantFieldName !== null).map((f) => f.variantFieldName);
+}
+var NON_WRITABLE_FIELDS = /* @__PURE__ */ new Set(["integer_id", "created_at", "updated_at"]);
+function generateReplaceVariablesField(entity) {
+  const fieldNames = entity.fields.map((f) => f.name).filter((name) => !NON_WRITABLE_FIELDS.has(name));
+  if (fieldNames.length === 0) return null;
+  const union = fieldNames.map((name) => `'${name}'`).join(" | ");
+  return [
+    "/**",
+    " * Field names whose template variables (e.g. `${replace_uuid.myNewEntity}`) the server",
+    " * should resolve to their concrete values during this upsert.",
+    " */",
+    `replace_variables?: Array<${union}>;`
+  ].join("\n");
+}
+function generateEntityFieldsType(entity) {
+  const lines = entity.fields.map((f) => `${f.name}: ${fieldTypeString(f)};`);
+  for (const variantName of getVariantFieldNames(entity)) {
+    lines.push(`${variantName}: ${VARIANT_TYPE}[] | null;`);
+  }
+  return lines.join("\n");
+}
+function generateEntityRelationsType(entity) {
+  if (entity.relations.length === 0) return "";
+  const lines = entity.relations.map(
+    (r) => `${r.fieldName}: { type: '${r.type}'; entity: '${r.targetEntityKey}' };`
+  );
+  return lines.join("\n");
+}
+function generateCreateInputType(entity) {
+  const lines = [];
+  for (const field of entity.fields) {
+    if (field.name === "id" || field.name === "integer_id") continue;
+    if (field.name === "created_at" || field.name === "updated_at") continue;
+    lines.push(`${field.name}?: ${fieldTypeString(field)};`);
+  }
+  for (const variantName of getVariantFieldNames(entity)) {
+    lines.push(`${variantName}?: ${VARIANT_TYPE}[];`);
+  }
+  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}?: ${valueType};`);
+    }
+  }
+  return lines.join("\n");
+}
+function generateUpdateInputType(entity) {
+  const lines = [];
+  lines.push("id?: string;");
+  lines.push(
+    "__search_value?: { field: string; value?: string; not_found_behavior?: 'create' | 'ignore' | 'error'; search_in_all_field_variants?: boolean; multiple_results_allowed?: boolean; multiple_results_use_latest?: boolean };"
+  );
+  const replaceVariables = generateReplaceVariablesField(entity);
+  if (replaceVariables) {
+    lines.push(replaceVariables);
+  }
+  for (const field of entity.fields) {
+    if (field.name === "id" || field.name === "integer_id") continue;
+    if (field.name === "created_at" || field.name === "updated_at") continue;
+    lines.push(`${field.name}?: ${fieldTypeString(field)};`);
+  }
+  for (const variantName of getVariantFieldNames(entity)) {
+    lines.push(`${variantName}?: ${VARIANT_TYPE}[];`);
+  }
+  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}?: ${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(
+    "// Auto-generated by @pylo/core codegen \u2014 DO NOT EDIT",
+    "",
+    "export type {",
+    "  FilterInput,",
+    "  PaginationData,",
+    "  PaginationInput,",
+    "  QueryInput,",
+    "  QueryInputCondition,",
+    "  QueryOperator,",
+    "  SortInput,",
+    "  SortOrder,",
+    "  SearchValueInput,",
+    `} 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));
+    lines.push("}", "");
+    lines.push(`export interface Update${entity.pascalName}Input {`);
+    lines.push(indent(generateUpdateInputType(entity), 1));
+    lines.push("}", "");
+  }
+  lines.push("export interface PyloSchema {");
+  for (const entity of entities) {
+    lines.push(`  ${entity.key}: {`);
+    lines.push("    fields: {");
+    lines.push(indent(generateEntityFieldsType(entity), 3));
+    lines.push("    };");
+    const relType = generateEntityRelationsType(entity);
+    lines.push("    relations: {");
+    if (relType) {
+      lines.push(indent(relType, 3));
+    }
+    lines.push("    };");
+    lines.push(`    createInput: Create${entity.pascalName}Input;`);
+    lines.push(`    updateInput: Update${entity.pascalName}Input;`);
+    lines.push("  };");
+  }
+  lines.push("}", "");
+  if (REGISTERABLE_SOURCES.has(importSource)) {
+    lines.push(
+      `declare module '${importSource}' {`,
+      "  interface PyloRegister {",
+      "    schema: PyloSchema;",
+      "  }",
+      "}",
+      ""
+    );
+  }
+  return lines.join("\n");
+}
+function generateEntitiesFile(entities, importSource) {
+  const lines = [];
+  lines.push(
+    "// Auto-generated by @pylo/core codegen \u2014 DO NOT EDIT",
+    "",
+    `import type { PaginationData } from '${importSource}';`
+  );
+  const enumTypes = collectEnumTypes(entities);
+  if (enumTypes.length > 0) {
+    const names = enumTypes.map((e) => e.typeName).join(", ");
+    lines.push(`import type { ${names} } from './index.js';`);
+  }
+  lines.push("");
+  for (const entity of entities) {
+    lines.push(`export interface ${entity.pascalName} {`);
+    for (const field of entity.fields) {
+      lines.push(`  ${field.name}: ${fieldTypeString(field)};`);
+    }
+    for (const variantName of getVariantFieldNames(entity)) {
+      lines.push(`  ${variantName}: ${VARIANT_TYPE}[] | null;`);
+    }
+    for (const rel of entity.relations) {
+      if (rel.type === "hasOne") {
+        lines.push(
+          `  ${rel.fieldName}?: { data: ${rel.targetEntityPascalName} } | null;`
+        );
+      } else {
+        lines.push(
+          `  ${rel.fieldName}?: { data: ${rel.targetEntityPascalName}[]; pagination: PaginationData };`
+        );
+      }
+    }
+    lines.push("}", "");
+  }
+  return lines.join("\n");
+}
+export {
+  ENTITY_LIST_QUERY,
+  analyzeEntities,
+  fetchSchemaWith,
+  generateEntitiesFile,
+  generateIndexFile
+};

package/dist/shared-types-DqRv2JHW.d.ts

@@ -0,0 +1,67 @@
+type QueryOperator = "equal" | "notEqual" | "greaterThan" | "lessThan" | "greaterThanOrEqual" | "lessThanOrEqual" | "isNull" | "isNotNull" | "like" | "notLike" | "ilike" | "notiLike" | "regex" | "notRegex" | "iregex" | "notiRegex" | "in" | "notIn" | "isEmpty" | "isNotEmpty" | "isTrue" | "isFalse";
+type SortOrder = "asc" | "desc";
+interface QueryInputCondition {
+    field: string;
+    operator: QueryOperator;
+    value?: string | number;
+    values?: Array<string | number>;
+}
+interface QueryInput {
+    and?: QueryInput[];
+    or?: QueryInput[];
+    condition?: QueryInputCondition;
+}
+interface SortInput {
+    field: string;
+    order: SortOrder;
+}
+interface FilterInput {
+    query?: QueryInput[];
+    sortby?: SortInput[];
+}
+interface PaginationInput {
+    page?: number;
+    per_page?: number;
+}
+interface PaginationData {
+    total: number;
+    current_page: number;
+    per_page: number;
+    last_page: number;
+    has_more_pages: boolean;
+}
+interface SearchValueInput {
+    field: string;
+    value?: string;
+    not_found_behavior?: "create" | "ignore" | "error";
+    search_in_all_field_variants?: boolean;
+    multiple_results_allowed?: boolean;
+    multiple_results_use_latest?: boolean;
+}
+interface PyloEventInput {
+    event_name: string;
+    properties: Record<string, unknown>;
+}
+interface PyloEvent {
+    event_name: string;
+    ts: string;
+    properties: Record<string, unknown>;
+}
+interface EntityMetadata {
+    pascalName: string;
+    scalarFieldNames: string[];
+    variantFieldNames?: string[];
+    jsonFieldNames?: string[];
+    enumFields?: Record<string, string[]>;
+    relations: Record<string, {
+        type: "hasOne" | "hasMany";
+        entity: string;
+        pascalName: string;
+    }>;
+}
+interface SchemaMetadata {
+    entities: Record<string, EntityMetadata>;
+    unknownFieldBehavior?: "error" | "ignore";
+}
+
+export type { EntityMetadata as E, FilterInput as F, PaginationInput as P, QueryInput as Q, SchemaMetadata as S, PaginationData as a, PyloEventInput as b, PyloEvent as c, QueryInputCondition as d, QueryOperator as e, SearchValueInput as f, SortInput as g, SortOrder as h };

package/package.json

@@ -1,15 +1,22 @@
 {
   "name": "@pylo/node",
-  "version": "0.0.11",
+  "version": "0.1.0",
   "description": "Server-side Pylo SDK with API key authentication",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     },
     "./codegen": {
       "types": "./dist/codegen.d.ts",
-      "import": "./dist/codegen.js"
+      "import": "./dist/codegen.js",
+      "default": "./dist/codegen.js"
+    },
+    "./schema": {
+      "types": "./dist/schema.d.ts",
+      "import": "./dist/schema.js",
+      "default": "./dist/schema.js"
     }
   },
   "main": "dist/index.js",
@@ -29,8 +36,8 @@
     "@types/node": "^22.15.21",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
-    "@pylo/auth": "0.0.5",
-    "@pylo/core": "0.0.13"
+    "@pylo/core": "0.1.0",
+    "@pylo/auth": "0.0.5"
   },
   "author": "Okeano GmbH",
   "license": "MIT",