@pylo/node 0.0.4 → 0.0.6

package/dist/cli.js

@@ -1,7 +1,463 @@
 #!/usr/bin/env node
 
+// ../core/dist/codegen/index.js
+import { resolve as resolve3 } from "path";
+import { resolve } from "path";
+import { existsSync } from "fs";
+import { createJiti } from "jiti";
+import { mkdirSync, writeFileSync } from "fs";
+import { resolve as resolve2 } from "path";
+var DEFAULT_ENDPOINT = "https://api.pyloapp.com/graphql";
+async function loadConfig(cwd) {
+  const candidates = ["pylo.config.ts", "pylo.config.js"];
+  for (const envFile of [".env", ".env.local"]) {
+    const envPath = resolve(cwd, envFile);
+    if (existsSync(envPath)) {
+      process.loadEnvFile(envPath);
+    }
+  }
+  const jiti = createJiti(cwd);
+  for (const filename of candidates) {
+    const configPath = resolve(cwd, filename);
+    if (existsSync(configPath)) {
+      const mod = await jiti.import(configPath);
+      if (!mod.default) {
+        throw new Error(
+          `${filename} must have a default export. Use defineConfig() from '@pylo/core/codegen'.`
+        );
+      }
+      const config = mod.default;
+      if (!config.apiKey) {
+        throw new Error(
+          `Missing 'apiKey' in ${filename}. An API key is required to introspect the Pylo schema.`
+        );
+      }
+      return {
+        endpoint: DEFAULT_ENDPOINT,
+        unknownFieldBehavior: "error",
+        ...config
+      };
+    }
+  }
+  throw new Error(
+    "No pylo.config.ts or pylo.config.js found in project root. Create one using defineConfig() from '@pylo/core/codegen'."
+  );
+}
+async function graphqlRequestWithApiKey(endpoint, query, variables, apiKey) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (apiKey) {
+    headers["pylo-api-key"] = apiKey;
+  }
+  const response = await fetch(endpoint, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ query, variables })
+  });
+  return response.json();
+}
+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_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 fetchSchema(config) {
+  var _a, _b;
+  const allEntities = [];
+  let page = 1;
+  let hasMore = true;
+  while (hasMore) {
+    const response = await graphqlRequestWithApiKey(
+      config.endpoint,
+      ENTITY_LIST_QUERY,
+      { pagination: { page, per_page: 50 } },
+      config.apiKey
+    );
+    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 analyzeField(field) {
+  var _a, _b;
+  const hasVariants = ((_b = (_a = field.variant_entity_field) == null ? void 0 : _a.data) == null ? void 0 : _b.name) != null;
+  return {
+    name: field.name,
+    tsType: mapDataType(field.data_type),
+    nullable: isNullable(field),
+    variantFieldName: hasVariants ? `${field.name}_variants` : 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(analyzeField);
+    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 }";
+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);
+}
+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) {
+      lines.push(
+        `${rel.fieldName}${suffix}?: Record<string, unknown>;`
+      );
+    }
+  }
+  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 };"
+  );
+  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) {
+      lines.push(
+        `${rel.fieldName}${suffix}?: Record<string, unknown>;`
+      );
+    }
+  }
+  return lines.join("\n");
+}
+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,",
+    "  SchemaMetadata,",
+    "  EntityMetadata,",
+    `} from '${importSource}';`,
+    ""
+  );
+  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("}", "");
+  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}';`,
+    ""
+  );
+  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");
+}
+function generateSchemaMetadataFile(entities, unknownFieldBehavior, importSource) {
+  const lines = [];
+  lines.push(
+    "// Auto-generated by @pylo/core codegen \u2014 DO NOT EDIT",
+    "",
+    `import type { SchemaMetadata } from '${importSource}';`,
+    "",
+    "export const schemaMetadata: SchemaMetadata = {",
+    `  unknownFieldBehavior: '${unknownFieldBehavior}',`,
+    "  entities: {"
+  );
+  for (const entity of entities) {
+    lines.push(`    ${entity.key}: {`);
+    lines.push(`      pascalName: '${entity.pascalName}',`);
+    const scalarNames = entity.fields.map((f) => `'${f.name}'`).join(", ");
+    lines.push(`      scalarFieldNames: [${scalarNames}],`);
+    const variantNames = getVariantFieldNames(entity);
+    if (variantNames.length > 0) {
+      const variantNamesStr = variantNames.map((n) => `'${n}'`).join(", ");
+      lines.push(`      variantFieldNames: [${variantNamesStr}],`);
+    }
+    lines.push("      relations: {");
+    for (const rel of entity.relations) {
+      lines.push(
+        `        ${rel.fieldName}: { type: '${rel.type}', entity: '${rel.targetEntityKey}', pascalName: '${rel.targetEntityPascalName}' },`
+      );
+    }
+    lines.push("      },");
+    lines.push("    },");
+  }
+  lines.push("  },", "};", "");
+  return lines.join("\n");
+}
+function writeGeneratedFiles(outputDir, files) {
+  mkdirSync(outputDir, { recursive: true });
+  for (const [filename, content] of Object.entries(files)) {
+    const filePath = resolve2(outputDir, filename);
+    writeFileSync(filePath, content, "utf-8");
+    console.log(`  wrote ${filePath}`);
+  }
+}
+async function generate(options) {
+  var _a, _b, _c;
+  const projectRoot = (_a = options == null ? void 0 : options.cwd) != null ? _a : process.cwd();
+  const importSource = (_b = options == null ? void 0 : options.importSource) != null ? _b : "@pylo/core";
+  console.log("Loading config...");
+  const config = await loadConfig(projectRoot);
+  const outputDir = resolve3(projectRoot, (_c = config.output) != null ? _c : ".pylo");
+  console.log("Fetching schema from Pylo...");
+  const rawEntities = await fetchSchema(config);
+  console.log(`  found ${rawEntities.length} entities`);
+  console.log("Analyzing entities...");
+  const entities = analyzeEntities(rawEntities);
+  console.log("Generating types...");
+  const files = {
+    "index.ts": generateIndexFile(entities, importSource),
+    "entities.ts": generateEntitiesFile(entities, importSource),
+    "schema-metadata.ts": generateSchemaMetadataFile(entities, config.unknownFieldBehavior, importSource)
+  };
+  console.log(`Writing files to ${outputDir}...`);
+  writeGeneratedFiles(outputDir, files);
+  console.log(
+    `
+Done! Generated types for ${entities.length} entities in ${outputDir}`
+  );
+  console.log(
+    "\nMake sure your tsconfig.json has path aliases set up:"
+  );
+  console.log('  "@pylo/types": ["./.pylo"]');
+  console.log('  "@pylo/types/*": ["./.pylo/*"]');
+}
+
 // src/cli.ts
-import { generate } from "@pylo/core/codegen";
 var args = process.argv.slice(2);
 var command = args[0];
 if (command === "generate") {

package/dist/codegen.js

@@ -1,5 +1,8 @@
-// src/codegen.ts
-import { defineConfig } from "@pylo/core/codegen";
+// ../core/dist/codegen/index.js
+import { createJiti } from "jiti";
+function defineConfig(config) {
+  return config;
+}
 export {
   defineConfig
 };

package/dist/index.d.ts

@@ -1,5 +1,168 @@
-import { SchemaMetadata, PyloClient } from '@pylo/core';
-export { AuthProvider, ByIdOptions, ClientOptions, EntityClient, EntityFields, EntityMetadata, EntityName, EntityRelations, EntityResult, EntitySelect, FilterInput, ListOptions, ListResult, PaginationData, PaginationInput, PyloClient, PyloError, QueryInput, QueryInputCondition, QueryOperator, RequestOptions, SchemaMetadata, SearchValueInput, SortInput, SortOrder, StrictSelect, UpsertInput } from '@pylo/core';
+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 EntityMetadata {
+    pascalName: string;
+    scalarFieldNames: string[];
+    variantFieldNames?: string[];
+    relations: Record<string, {
+        type: "hasOne" | "hasMany";
+        entity: string;
+        pascalName: string;
+    }>;
+}
+interface SchemaMetadata {
+    entities: Record<string, EntityMetadata>;
+    unknownFieldBehavior?: "error" | "ignore";
+}
+
+type EntityName<S> = string & keyof S;
+type EntityFields<S, E extends EntityName<S>> = S[E] extends {
+    fields: infer F;
+} ? F : never;
+type EntityRelations<S, E extends EntityName<S>> = S[E] extends {
+    relations: infer R;
+} ? R : never;
+type UpsertInput<S, E extends EntityName<S>> = S[E] extends {
+    updateInput: infer U;
+} ? U : Record<string, unknown>;
+type OmitNever<T> = {
+    [K in keyof T as T[K] extends never ? never : K]: T[K];
+};
+type EntitySelect<S, E extends EntityName<S>, Depth extends number = 0> = Depth extends 5 ? Record<string, true> : OmitNever<{
+    [K in keyof EntityFields<S, E>]?: true;
+}> & {
+    [K in keyof EntityRelations<S, E>]?: EntityRelations<S, E>[K] extends {
+        type: "hasOne";
+        entity: infer Target;
+    } ? Target extends EntityName<S> ? true | {
+        select?: EntitySelect<S, Target, Increment[Depth]>;
+        filter?: FilterInput;
+    } : true : EntityRelations<S, E>[K] extends {
+        type: "hasMany";
+        entity: infer Target;
+    } ? Target extends EntityName<S> ? true | {
+        select?: EntitySelect<S, Target, Increment[Depth]>;
+        filter?: FilterInput;
+        pagination?: PaginationInput;
+    } : true : true;
+};
+type Increment = [1, 2, 3, 4, 5, 5];
+type EntityResult<S, E extends EntityName<S>, Select extends EntitySelect<S, E> | undefined = undefined, Depth extends number = 0> = Depth extends 5 ? Record<string, unknown> : Select extends undefined ? EntityFields<S, E> : Select extends EntitySelect<S, E> ? OmitNever<ScalarResult<S, E, Select> & RelationResult<S, E, Select, Depth>> : EntityFields<S, E>;
+type ScalarResult<S, E extends EntityName<S>, Select extends EntitySelect<S, E>> = {
+    [K in keyof Select & keyof EntityFields<S, E>]: Select[K] extends true ? EntityFields<S, E>[K] : never;
+};
+type RelationResult<S, E extends EntityName<S>, Select extends EntitySelect<S, E>, Depth extends number = 0> = {
+    [K in keyof Select & keyof EntityRelations<S, E>]: EntityRelations<S, E>[K] extends {
+        type: "hasOne";
+        entity: infer Target;
+    } ? Target extends EntityName<S> ? Select[K] extends {
+        select: infer SubSelect;
+    } ? SubSelect extends EntitySelect<S, Target> ? {
+        data: EntityResult<S, Target, SubSelect, Increment[Depth]>;
+    } | null : {
+        data: EntityFields<S, Target>;
+    } | null : Select[K] extends true ? {
+        data: EntityFields<S, Target>;
+    } | null : never : never : EntityRelations<S, E>[K] extends {
+        type: "hasMany";
+        entity: infer Target;
+    } ? Target extends EntityName<S> ? Select[K] extends {
+        select: infer SubSelect;
+    } ? SubSelect extends EntitySelect<S, Target> ? {
+        data: Array<EntityResult<S, Target, SubSelect, Increment[Depth]>>;
+        pagination: PaginationData;
+    } : {
+        data: Array<EntityFields<S, Target>>;
+        pagination: PaginationData;
+    } : Select[K] extends true ? {
+        data: Array<EntityFields<S, Target>>;
+        pagination: PaginationData;
+    } : never : never : never;
+};
+type StrictSelect<Sel, Valid> = Valid & {
+    [K in keyof Sel]: K extends keyof Valid ? Sel[K] : never;
+};
+type ListOptions<S, E extends EntityName<S>, Sel extends EntitySelect<S, E> | undefined = undefined> = {
+    select?: Sel extends undefined ? EntitySelect<S, E> : StrictSelect<Sel, EntitySelect<S, E>>;
+    filter?: FilterInput;
+    pagination?: PaginationInput;
+};
+type ByIdOptions<S, E extends EntityName<S>, Sel extends EntitySelect<S, E> | undefined = undefined> = {
+    select?: Sel extends undefined ? EntitySelect<S, E> : StrictSelect<Sel, EntitySelect<S, E>>;
+};
+interface ListResult<T> {
+    data: T[];
+    pagination: PaginationData;
+}
+interface RequestOptions {
+    headers?: Record<string, string>;
+}
+
+declare class PyloError extends Error {
+    graphqlErrors: unknown;
+    constructor(message: string, graphqlErrors?: unknown);
+}
+type AuthProvider = () => Promise<{
+    token?: string;
+    apiKey?: string;
+}>;
+interface ClientOptions {
+    endpoint?: string;
+    schemaMetadata: SchemaMetadata;
+    auth: AuthProvider;
+    headers?: Record<string, string>;
+}
+interface EntityClient<S, E extends EntityName<S>> {
+    list<Sel extends EntitySelect<S, E> | undefined = undefined>(options?: ListOptions<S, E, Sel> & RequestOptions): Promise<ListResult<EntityResult<S, E, Sel>>>;
+    byId<Sel extends EntitySelect<S, E> | undefined = undefined>(id: string, options?: ByIdOptions<S, E, Sel> & RequestOptions): Promise<EntityResult<S, E, Sel> | null>;
+    upsert(input: UpsertInput<S, E>, options?: RequestOptions): Promise<{
+        id: string;
+    }>;
+    delete(ids: string[], options?: RequestOptions): Promise<{
+        success: boolean;
+    }>;
+}
+type PyloClient<S> = {
+    [E in EntityName<S>]: EntityClient<S, E>;
+};
 
 interface NodeClientOptions {
     apiKey: string;
@@ -9,4 +172,4 @@ interface NodeClientOptions {
 }
 declare function createPyloNode<S>(options: NodeClientOptions): PyloClient<S>;
 
-export { createPyloNode };
+export { type AuthProvider, type ByIdOptions, type ClientOptions, type EntityClient, type EntityFields, type EntityMetadata, type EntityName, type EntityRelations, type EntityResult, type EntitySelect, type FilterInput, type ListOptions, type ListResult, type PaginationData, type PaginationInput, type PyloClient, PyloError, type QueryInput, type QueryInputCondition, type QueryOperator, type RequestOptions, type SchemaMetadata, type SearchValueInput, type SortInput, type SortOrder, type StrictSelect, type UpsertInput, createPyloNode };

package/dist/index.js

@@ -1,6 +1,372 @@
+// ../auth/dist/index.js
+var DEFAULT_GRAPHQL_ENDPOINT = "https://api.pyloapp.com/graphql";
+function extractErrorMessage(errors) {
+  var _a, _b, _c, _d;
+  if (!errors) return null;
+  if (Array.isArray(errors) && errors.length > 0) {
+    return (_b = (_a = errors[0]) == null ? void 0 : _a.message) != null ? _b : null;
+  }
+  if (typeof errors === "object" && "generalError" in errors) {
+    return (_d = (_c = errors.generalError) == null ? void 0 : _c.message) != null ? _d : null;
+  }
+  return null;
+}
+function hasErrors(response) {
+  return extractErrorMessage(response.errors) !== null;
+}
+function mergeHeaders(global, perOp) {
+  if (!global && !perOp) return void 0;
+  return { ...global, ...perOp };
+}
+var PROTECTED_HEADERS = /* @__PURE__ */ new Set(["authorization", "pylo-api-key", "content-type"]);
+function stripProtectedHeaders(custom) {
+  const result = {};
+  for (const [key, value] of Object.entries(custom)) {
+    if (!PROTECTED_HEADERS.has(key.toLowerCase())) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+async function graphqlRequest(endpoint, query, variables, options) {
+  const headers = {
+    ...(options == null ? void 0 : options.headers) ? stripProtectedHeaders(options.headers) : {},
+    "Content-Type": "application/json"
+  };
+  if (options == null ? void 0 : options.token) {
+    headers["Authorization"] = `Bearer ${options.token}`;
+  }
+  if (options == null ? void 0 : options.apiKey) {
+    headers["pylo-api-key"] = options.apiKey;
+  }
+  const response = await fetch(endpoint, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ query, variables })
+  });
+  return response.json();
+}
+
+// ../core/dist/index.js
+var PAGINATION_FIELDS = `pagination {
+    total
+    current_page
+    per_page
+    last_page
+    has_more_pages
+  }`;
+function buildSelectionSet(select, entityMeta, schemaMetadata, variables, variableTypes, prefix) {
+  var _a, _b;
+  const fields = [];
+  const variantFieldNames = (_a = entityMeta.variantFieldNames) != null ? _a : [];
+  if (!select) {
+    fields.push(...entityMeta.scalarFieldNames);
+    for (const vf of variantFieldNames) {
+      fields.push(`${vf} { data { value variant } }`);
+    }
+    return fields.join("\n    ");
+  }
+  for (const [key, value] of Object.entries(select)) {
+    if (entityMeta.scalarFieldNames.includes(key)) {
+      if (value === true) {
+        fields.push(key);
+      }
+      continue;
+    }
+    if (variantFieldNames.includes(key)) {
+      if (value === true) {
+        fields.push(`${key} { data { value variant } }`);
+      }
+      continue;
+    }
+    const relation = entityMeta.relations[key];
+    if (!relation) {
+      if (schemaMetadata.unknownFieldBehavior === "ignore") continue;
+      const validFields = [...entityMeta.scalarFieldNames, ...variantFieldNames].join(", ");
+      const validRelations = Object.keys(entityMeta.relations).join(", ");
+      throw new Error(
+        `Unknown field "${key}" on entity "${entityMeta.pascalName}". Valid fields: ${validFields}. Valid relations: ${validRelations}`
+      );
+    }
+    const targetMeta = schemaMetadata.entities[relation.entity];
+    if (!targetMeta) continue;
+    const isHasMany = relation.type === "hasMany";
+    if (value === true) {
+      const targetFieldParts = [...targetMeta.scalarFieldNames];
+      for (const vf of (_b = targetMeta.variantFieldNames) != null ? _b : []) {
+        targetFieldParts.push(`${vf} { data { value variant } }`);
+      }
+      const targetFields = targetFieldParts.join(" ");
+      if (isHasMany) {
+        fields.push(`${key} { data { ${targetFields} } ${PAGINATION_FIELDS} }`);
+      } else {
+        fields.push(`${key} { data { ${targetFields} } }`);
+      }
+    } else if (typeof value === "object" && value !== null) {
+      const argParts = [];
+      if (value.filter !== void 0) {
+        const varName = `${prefix}${key}_filter`;
+        variables[varName] = value.filter;
+        variableTypes.set(varName, "FilterInput");
+        argParts.push(`filter: $${varName}`);
+      }
+      if (isHasMany && value.pagination !== void 0) {
+        const varName = `${prefix}${key}_pagination`;
+        variables[varName] = value.pagination;
+        variableTypes.set(varName, "PaginationInput");
+        argParts.push(`pagination: $${varName}`);
+      }
+      const args = argParts.length > 0 ? `(${argParts.join(", ")})` : "";
+      const nestedSelection = buildSelectionSet(
+        value.select,
+        targetMeta,
+        schemaMetadata,
+        variables,
+        variableTypes,
+        `${prefix}${key}_`
+      );
+      if (isHasMany) {
+        fields.push(
+          `${key}${args} { data { ${nestedSelection} } ${PAGINATION_FIELDS} }`
+        );
+      } else {
+        fields.push(`${key}${args} { data { ${nestedSelection} } }`);
+      }
+    }
+  }
+  return fields.join("\n    ");
+}
+function buildListQuery(entityKey, options, schemaMetadata) {
+  const entityMeta = schemaMetadata.entities[entityKey];
+  if (!entityMeta) {
+    throw new Error(`Unknown entity: ${entityKey}`);
+  }
+  const variables = {};
+  const variableTypes = /* @__PURE__ */ new Map();
+  if ((options == null ? void 0 : options.filter) !== void 0) {
+    variables["filter"] = options.filter;
+    variableTypes.set("filter", "FilterInput");
+  }
+  if ((options == null ? void 0 : options.pagination) !== void 0) {
+    variables["pagination"] = options.pagination;
+    variableTypes.set("pagination", "PaginationInput");
+  }
+  const selectionSet = buildSelectionSet(
+    options == null ? void 0 : options.select,
+    entityMeta,
+    schemaMetadata,
+    variables,
+    variableTypes,
+    "r_"
+  );
+  const varDecls = Array.from(variableTypes.entries()).map(([name, type]) => `$${name}: ${type}`).join(", ");
+  const varSection = varDecls ? `(${varDecls})` : "";
+  const argParts = [];
+  if (variableTypes.has("filter")) {
+    argParts.push("filter: $filter");
+  }
+  if (variableTypes.has("pagination")) {
+    argParts.push("pagination: $pagination");
+  }
+  const argSection = argParts.length > 0 ? `(${argParts.join(", ")})` : "";
+  const queryName = `${entityKey}List`;
+  const query = `query ${capitalize(entityKey)}List${varSection} {
+  ${queryName}${argSection} {
+    data {
+      ${selectionSet}
+    }
+    ${PAGINATION_FIELDS}
+  }
+}`;
+  return { query, variables };
+}
+function buildByIdQuery(entityKey, id, options, schemaMetadata) {
+  const entityMeta = schemaMetadata.entities[entityKey];
+  if (!entityMeta) {
+    throw new Error(`Unknown entity: ${entityKey}`);
+  }
+  const variables = { id };
+  const variableTypes = /* @__PURE__ */ new Map([["id", "ID!"]]);
+  const selectionSet = buildSelectionSet(
+    options == null ? void 0 : options.select,
+    entityMeta,
+    schemaMetadata,
+    variables,
+    variableTypes,
+    "r_"
+  );
+  const varDecls = Array.from(variableTypes.entries()).map(([name, type]) => `$${name}: ${type}`).join(", ");
+  const query = `query ${capitalize(entityKey)}ById(${varDecls}) {
+  ${entityKey}ById(id: $id) {
+    data {
+      ${selectionSet}
+    }
+  }
+}`;
+  return { query, variables };
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function buildUpsertMutation(_entityKey, pascalName, input) {
+  const mutation = `mutation Update${pascalName}($input: Update${pascalName}Input!) {
+  update${pascalName}(input: $input) {
+    data {
+      id
+    }
+  }
+}`;
+  return {
+    query: mutation,
+    variables: { input }
+  };
+}
+function buildDeleteMutation(_entityKey, pascalName, ids) {
+  const mutation = `mutation Delete${pascalName}($ids: [ID!]!) {
+  delete${pascalName}(ids: $ids) {
+    data {
+      success
+    }
+  }
+}`;
+  return {
+    query: mutation,
+    variables: { ids }
+  };
+}
+var PyloError = class extends Error {
+  constructor(message, graphqlErrors) {
+    super(message);
+    this.name = "PyloError";
+    this.graphqlErrors = graphqlErrors;
+  }
+};
+function getEndpoint(endpoint) {
+  var _a;
+  if (endpoint) return endpoint;
+  return (_a = process.env["PYLO_GRAPHQL_ENDPOINT"]) != null ? _a : DEFAULT_GRAPHQL_ENDPOINT;
+}
+async function executeGraphQL(endpoint, query, variables, auth, headers) {
+  var _a;
+  const credentials = await auth();
+  const response = await graphqlRequest(endpoint, query, variables, {
+    ...credentials,
+    ...headers !== void 0 ? { headers } : {}
+  });
+  if (hasErrors(response)) {
+    const message = (_a = extractErrorMessage(response.errors)) != null ? _a : "GraphQL request failed";
+    throw new PyloError(message, response.errors);
+  }
+  if (!response.data) {
+    throw new PyloError("No data returned from GraphQL request");
+  }
+  return response.data;
+}
+function createEntityClient(entityKey, endpoint, metadata, auth, globalHeaders) {
+  return {
+    async list(options) {
+      const { query, variables } = buildListQuery(
+        entityKey,
+        options,
+        metadata
+      );
+      const data = await executeGraphQL(
+        endpoint,
+        query,
+        variables,
+        auth,
+        mergeHeaders(globalHeaders, options == null ? void 0 : options.headers)
+      );
+      const listKey = `${entityKey}List`;
+      const result = data[listKey];
+      if (!result) {
+        throw new PyloError(`Unexpected response shape \u2014 missing ${listKey}`);
+      }
+      return { data: result.data, pagination: result.pagination };
+    },
+    async byId(id, options) {
+      const { query, variables } = buildByIdQuery(
+        entityKey,
+        id,
+        options,
+        metadata
+      );
+      const data = await executeGraphQL(
+        endpoint,
+        query,
+        variables,
+        auth,
+        mergeHeaders(globalHeaders, options == null ? void 0 : options.headers)
+      );
+      const byIdKey = `${entityKey}ById`;
+      const result = data[byIdKey];
+      if (!result) return null;
+      return result.data;
+    },
+    async upsert(input, options) {
+      const entityMeta = metadata.entities[entityKey];
+      if (!entityMeta) {
+        throw new PyloError(`Unknown entity: ${entityKey}`);
+      }
+      const { query, variables } = buildUpsertMutation(
+        entityKey,
+        entityMeta.pascalName,
+        input
+      );
+      const data = await executeGraphQL(
+        endpoint,
+        query,
+        variables,
+        auth,
+        mergeHeaders(globalHeaders, options == null ? void 0 : options.headers)
+      );
+      const mutationKey = `update${entityMeta.pascalName}`;
+      const result = data[mutationKey];
+      if (!result) {
+        throw new PyloError(`Unexpected response shape \u2014 missing ${mutationKey}`);
+      }
+      return result.data;
+    },
+    async delete(ids, options) {
+      const entityMeta = metadata.entities[entityKey];
+      if (!entityMeta) {
+        throw new PyloError(`Unknown entity: ${entityKey}`);
+      }
+      const { query, variables } = buildDeleteMutation(
+        entityKey,
+        entityMeta.pascalName,
+        ids
+      );
+      const data = await executeGraphQL(
+        endpoint,
+        query,
+        variables,
+        auth,
+        mergeHeaders(globalHeaders, options == null ? void 0 : options.headers)
+      );
+      const mutationKey = `delete${entityMeta.pascalName}`;
+      const result = data[mutationKey];
+      if (!result) {
+        throw new PyloError(`Unexpected response shape \u2014 missing ${mutationKey}`);
+      }
+      return result.data;
+    }
+  };
+}
+function createPyloClient(options) {
+  const endpoint = getEndpoint(options.endpoint);
+  const metadata = options.schemaMetadata;
+  const auth = options.auth;
+  const globalHeaders = options.headers;
+  return new Proxy({}, {
+    get(_target, prop) {
+      if (typeof prop !== "string") return void 0;
+      return createEntityClient(prop, endpoint, metadata, auth, globalHeaders);
+    }
+  });
+}
+
 // src/index.ts
-import { createPyloClient } from "@pylo/core";
-import { PyloError } from "@pylo/core";
 function createPyloNode(options) {
   return createPyloClient({
     ...options.endpoint !== void 0 ? { endpoint: options.endpoint } : {},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pylo/node",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Server-side Pylo SDK with API key authentication",
   "exports": {
     ".": {
@@ -22,12 +22,14 @@
     "dist"
   ],
   "dependencies": {
-    "@pylo/core": "0.0.6"
+    "jiti": "^2.6.1"
   },
   "devDependencies": {
     "@types/node": "^22.15.21",
     "tsup": "^8.5.1",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "@pylo/core": "0.0.8",
+    "@pylo/auth": "0.0.4"
   },
   "license": "ISC",
   "scripts": {