@eide/uniformgen 0.1.0

package/dist/generators/documents/entity-models.js

@@ -0,0 +1,87 @@
+import { toPascalCase } from '../../utils/field-mapping.js';
+/**
+ * Generate GraphQL documents for an entity model
+ * Uses generic entity/entities operations
+ */
+export function generateEntityModelDocuments(model) {
+    const typeName = toPascalCase(model.key);
+    const pluralName = model.pluralName
+        ? toPascalCase(model.pluralName.replace(/\s+/g, ''))
+        : `${typeName}s`;
+    return `# Generated GraphQL operations for ${model.name}
+# @generated by UniformGen - DO NOT EDIT MANUALLY
+
+fragment ${typeName}Fields on EntityRecord {
+  id
+  modelKey
+  naturalKey
+  data
+  metadata
+  versionNumber
+  publishedVersionNumber
+  status
+  createdAt
+  updatedAt
+}
+
+query Get${typeName}($id: ID!, $preview: Boolean) {
+  entity(modelKey: "${model.key}", id: $id, preview: $preview) {
+    ...${typeName}Fields
+  }
+}
+
+query List${pluralName}(
+  $limit: Int
+  $offset: Int
+  $filters: [FilterInput!]
+  $sort: SortInput
+  $preview: Boolean
+) {
+  entities(
+    modelKey: "${model.key}"
+    limit: $limit
+    offset: $offset
+    filters: $filters
+    sort: $sort
+    preview: $preview
+  ) {
+    items {
+      ...${typeName}Fields
+    }
+    total
+    hasMore
+  }
+}
+
+mutation Create${typeName}($data: JSON!) {
+  createEntity(modelKey: "${model.key}", data: $data) {
+    ...${typeName}Fields
+  }
+}
+
+mutation Update${typeName}($id: ID!, $data: JSON!) {
+  updateEntity(modelKey: "${model.key}", id: $id, data: $data) {
+    ...${typeName}Fields
+  }
+}
+
+mutation Delete${typeName}($id: ID!) {
+  deleteEntity(modelKey: "${model.key}", id: $id) {
+    success
+    message
+  }
+}
+
+mutation Publish${typeName}($id: ID!, $versionId: ID) {
+  publishEntity(modelKey: "${model.key}", id: $id, versionId: $versionId) {
+    ...${typeName}Fields
+  }
+}
+
+mutation Unpublish${typeName}($id: ID!) {
+  unpublishEntity(modelKey: "${model.key}", id: $id) {
+    ...${typeName}Fields
+  }
+}
+`;
+}

package/dist/generators/documents/workflows.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Workflow Documents Generator
+ *
+ * Generates shared GraphQL documents for workflow operations.
+ * These are used by both React hooks and Remix server functions.
+ */
+/**
+ * Generate the shared workflow GraphQL documents file
+ */
+export declare function generateWorkflowDocuments(): string;
+//# sourceMappingURL=workflows.d.ts.map

package/dist/generators/documents/workflows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflows.d.ts","sourceRoot":"","sources":["../../../src/generators/documents/workflows.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;GAEG;AACH,wBAAgB,yBAAyB,IAAI,MAAM,CAiGlD"}

package/dist/generators/documents/workflows.js

@@ -0,0 +1,101 @@
+/**
+ * Workflow Documents Generator
+ *
+ * Generates shared GraphQL documents for workflow operations.
+ * These are used by both React hooks and Remix server functions.
+ */
+/**
+ * Generate the shared workflow GraphQL documents file
+ */
+export function generateWorkflowDocuments() {
+    const lines = [];
+    lines.push('/**');
+    lines.push(' * Workflow GraphQL Documents');
+    lines.push(' * @generated by UniformGen - DO NOT EDIT MANUALLY');
+    lines.push(' */');
+    lines.push('');
+    lines.push("import { gql } from 'graphql-request';");
+    lines.push('');
+    // Execute workflow mutation
+    lines.push('/**');
+    lines.push(' * Execute a workflow via the public API');
+    lines.push(' */');
+    lines.push('export const PublicExecuteWorkflowDocument = gql`');
+    lines.push('  mutation PublicExecuteWorkflow($input: PublicExecuteWorkflowInput!) {');
+    lines.push('    publicExecuteWorkflow(input: $input) {');
+    lines.push('      success');
+    lines.push('      executionId');
+    lines.push('      queued');
+    lines.push('      result');
+    lines.push('      error {');
+    lines.push('        code');
+    lines.push('        message');
+    lines.push('      }');
+    lines.push('    }');
+    lines.push('  }');
+    lines.push('`;');
+    lines.push('');
+    // Get workflow execution query
+    lines.push('/**');
+    lines.push(' * Get workflow execution status');
+    lines.push(' */');
+    lines.push('export const PublicWorkflowExecutionDocument = gql`');
+    lines.push('  query PublicWorkflowExecution($id: ID!) {');
+    lines.push('    publicWorkflowExecution(id: $id) {');
+    lines.push('      id');
+    lines.push('      workflowKey');
+    lines.push('      status');
+    lines.push('      result');
+    lines.push('      error {');
+    lines.push('        code');
+    lines.push('        message');
+    lines.push('      }');
+    lines.push('      createdAt');
+    lines.push('      completedAt');
+    lines.push('    }');
+    lines.push('  }');
+    lines.push('`;');
+    lines.push('');
+    // List workflow executions query
+    lines.push('/**');
+    lines.push(' * List workflow executions');
+    lines.push(' */');
+    lines.push('export const PublicWorkflowExecutionsDocument = gql`');
+    lines.push('  query PublicWorkflowExecutions(');
+    lines.push('    $workflowKey: String');
+    lines.push('    $status: PublicWorkflowExecutionStatus');
+    lines.push('    $limit: Int');
+    lines.push('    $offset: Int');
+    lines.push('  ) {');
+    lines.push('    publicWorkflowExecutions(');
+    lines.push('      workflowKey: $workflowKey');
+    lines.push('      status: $status');
+    lines.push('      limit: $limit');
+    lines.push('      offset: $offset');
+    lines.push('    ) {');
+    lines.push('      items {');
+    lines.push('        id');
+    lines.push('        workflowKey');
+    lines.push('        status');
+    lines.push('        createdAt');
+    lines.push('        completedAt');
+    lines.push('      }');
+    lines.push('      total');
+    lines.push('    }');
+    lines.push('  }');
+    lines.push('`;');
+    lines.push('');
+    // Cancel workflow execution mutation
+    lines.push('/**');
+    lines.push(' * Cancel a workflow execution');
+    lines.push(' */');
+    lines.push('export const PublicCancelWorkflowExecutionDocument = gql`');
+    lines.push('  mutation PublicCancelWorkflowExecution($id: ID!) {');
+    lines.push('    publicCancelWorkflowExecution(id: $id) {');
+    lines.push('      id');
+    lines.push('      status');
+    lines.push('    }');
+    lines.push('  }');
+    lines.push('`;');
+    return lines.join('\n') + '\n';
+}

package/dist/generators/filters/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Filter Type Generator
+ *
+ * Generates typed filter interfaces and buildFilters helpers
+ * with support for nested object filtering and metadata fields.
+ */
+import type { EntityModel } from '../../fetcher/fetch-schemas.js';
+/**
+ * Generate the filter types file for a model
+ */
+export declare function generateModelFilters(model: EntityModel, allModels: EntityModel[]): string;
+/**
+ * Generate index file for filters
+ */
+export declare function generateFiltersIndex(models: EntityModel[]): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/generators/filters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/generators/filters/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAoC,MAAM,gCAAgC,CAAC;AAyPpG;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,WAAW,EAClB,SAAS,EAAE,WAAW,EAAE,GACvB,MAAM,CAgJR;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,CAmClE"}

package/dist/generators/filters/index.js

@@ -0,0 +1,384 @@
+/**
+ * Filter Type Generator
+ *
+ * Generates typed filter interfaces and buildFilters helpers
+ * with support for nested object filtering and metadata fields.
+ */
+import { toPascalCase, sanitizeFieldName } from '../../utils/field-mapping.js';
+import { PRIMITIVE_FIELD_TYPES } from '../../utils/field-mapping.js';
+/**
+ * Map field type to filter type name
+ */
+function getFilterTypeName(fieldType, field) {
+    switch (fieldType) {
+        case 'text':
+        case 'richtext':
+        case 'email':
+        case 'phone':
+        case 'url':
+            return 'TextFilter';
+        case 'number':
+        case 'currency':
+            return 'NumberFilter';
+        case 'boolean':
+            return 'BooleanFilter';
+        case 'date':
+            return 'DateFilter';
+        case 'select':
+            // Check if we have options to create a literal union
+            if (field.options?.options && Array.isArray(field.options.options)) {
+                const values = field.options.options
+                    .map((o) => `'${o.value}'`)
+                    .join(' | ');
+                return `SelectFilter<${values}>`;
+            }
+            return 'SelectFilter';
+        case 'multiselect':
+            if (field.options?.options && Array.isArray(field.options.options)) {
+                const values = field.options.options
+                    .map((o) => `'${o.value}'`)
+                    .join(' | ');
+                return `MultiselectFilter<${values}>`;
+            }
+            return 'MultiselectFilter';
+        case 'entity-reference':
+            return 'ReferenceFilter';
+        case 'image':
+        case 'video':
+        case 'file':
+        case 'link':
+        case 'json':
+        case 'design-system-style':
+            // These types typically aren't filtered directly
+            return null;
+        default:
+            // Non-primitive type - could be inline schema reference
+            return null;
+    }
+}
+/**
+ * Map metadata field type to filter type name
+ */
+function getMetadataFilterTypeName(fieldType) {
+    switch (fieldType) {
+        case 'string':
+            return 'TextFilter';
+        case 'number':
+            return 'NumberFilter';
+        case 'boolean':
+            return 'BooleanFilter';
+        case 'date':
+            return 'DateFilter';
+        case 'array':
+        case 'object':
+            // Complex types - not directly filterable but could contain nested paths
+            return null;
+        default:
+            return null;
+    }
+}
+/**
+ * Check if a field type is filterable
+ */
+function isFilterableField(fieldType) {
+    const filterableTypes = [
+        'text',
+        'richtext',
+        'email',
+        'phone',
+        'url',
+        'number',
+        'currency',
+        'boolean',
+        'date',
+        'select',
+        'multiselect',
+        'entity-reference',
+    ];
+    return filterableTypes.includes(fieldType);
+}
+/**
+ * Check if a field type is a primitive (built-in) type
+ */
+function isPrimitiveFieldType(type) {
+    return PRIMITIVE_FIELD_TYPES.has(type);
+}
+/**
+ * Build a nested object structure from dot-notation paths
+ * e.g., 'synced.shopifyProductId' -> { synced: { shopifyProductId: 'TextFilter' } }
+ */
+function buildNestedStructure(fields, depth = 0) {
+    // Group fields by their first path segment
+    const groups = new Map();
+    const directFields = [];
+    for (const field of fields) {
+        const parts = field.key.split('.');
+        if (parts.length === 1) {
+            directFields.push(field);
+        }
+        else {
+            const firstPart = parts[0]; // Guaranteed to exist when parts.length > 1
+            const remaining = {
+                ...field,
+                key: parts.slice(1).join('.'),
+            };
+            if (!groups.has(firstPart)) {
+                groups.set(firstPart, []);
+            }
+            groups.get(firstPart).push(remaining);
+        }
+    }
+    const indent = '  '.repeat(depth + 1);
+    const lines = [];
+    // Add direct fields
+    for (const field of directFields) {
+        const filterType = getMetadataFilterTypeName(field.type);
+        if (filterType) {
+            const fieldName = sanitizeFieldName(field.key);
+            lines.push(`${indent}${fieldName}?: ${filterType};`);
+        }
+    }
+    // Add nested groups
+    for (const [groupName, groupFields] of groups) {
+        const nestedStructure = buildNestedStructure(groupFields, depth + 1);
+        if (nestedStructure !== '{}') {
+            const fieldName = sanitizeFieldName(groupName);
+            lines.push(`${indent}${fieldName}?: ${nestedStructure}`);
+        }
+    }
+    if (lines.length === 0) {
+        return '{}';
+    }
+    const closeIndent = '  '.repeat(depth);
+    return `{\n${lines.join('\n')}\n${closeIndent}}`;
+}
+/**
+ * Generate filter interface for metadata fields
+ */
+function generateMetadataFilterInterface(metadataFields, depth = 0) {
+    if (!metadataFields || metadataFields.length === 0) {
+        return '';
+    }
+    return buildNestedStructure(metadataFields, depth);
+}
+/**
+ * Generate filter interface for a model's fields, with nested support
+ */
+function generateFilterInterface(model, allModels, depth = 0, visited = new Set()) {
+    // Prevent infinite recursion
+    if (visited.has(model.key)) {
+        return '{}';
+    }
+    visited.add(model.key);
+    const indent = '  '.repeat(depth + 1);
+    const lines = [];
+    for (const field of model.fields) {
+        const fieldName = sanitizeFieldName(field.key);
+        // Check if it's a primitive filterable type
+        if (isPrimitiveFieldType(field.type) && isFilterableField(field.type)) {
+            const filterType = getFilterTypeName(field.type, field);
+            if (filterType) {
+                lines.push(`${indent}${fieldName}?: ${filterType};`);
+            }
+        }
+        // Check if it's an inline schema reference
+        else if (!isPrimitiveFieldType(field.type)) {
+            const referencedModel = allModels.find((m) => m.key === field.type);
+            if (referencedModel && referencedModel.modes.inline) {
+                // Recursively generate nested filter structure
+                const nestedInterface = generateFilterInterface(referencedModel, allModels, depth + 1, new Set(visited));
+                if (nestedInterface !== '{}') {
+                    lines.push(`${indent}${fieldName}?: ${nestedInterface}`);
+                }
+            }
+        }
+        // Handle list fields with inline item types
+        else if (field.type === 'list' && field.options?.itemType) {
+            const itemType = field.options.itemType;
+            if (!isPrimitiveFieldType(itemType)) {
+                const referencedModel = allModels.find((m) => m.key === itemType);
+                if (referencedModel && referencedModel.modes.inline) {
+                    const nestedInterface = generateFilterInterface(referencedModel, allModels, depth + 1, new Set(visited));
+                    if (nestedInterface !== '{}') {
+                        lines.push(`${indent}${fieldName}?: ${nestedInterface}`);
+                    }
+                }
+            }
+        }
+    }
+    if (lines.length === 0) {
+        return '{}';
+    }
+    const closeIndent = '  '.repeat(depth);
+    return `{\n${lines.join('\n')}\n${closeIndent}}`;
+}
+/**
+ * Generate the filter types file for a model
+ */
+export function generateModelFilters(model, allModels) {
+    // Skip inline-only models - they don't have standalone queries
+    if (model.modes.inline && !model.modes.records) {
+        return '';
+    }
+    const typeName = toPascalCase(model.key);
+    const lines = [];
+    // File header
+    lines.push(`/**`);
+    lines.push(` * ${model.name} - Typed Filters`);
+    lines.push(` *`);
+    lines.push(` * @generated by UniformGen - DO NOT EDIT MANUALLY`);
+    lines.push(` */`);
+    lines.push('');
+    // Imports
+    lines.push(`import type {`);
+    lines.push(`  TextFilter,`);
+    lines.push(`  NumberFilter,`);
+    lines.push(`  BooleanFilter,`);
+    lines.push(`  DateFilter,`);
+    lines.push(`  SelectFilter,`);
+    lines.push(`  MultiselectFilter,`);
+    lines.push(`  ReferenceFilter,`);
+    lines.push(`  FilterInput,`);
+    lines.push(`} from '../types/field-types.js';`);
+    lines.push('');
+    // Generate the data filter interface
+    const dataFilterInterface = generateFilterInterface(model, allModels, 1);
+    // Generate the metadata filter interface if metadataSchema exists
+    const metadataFields = model.metadataSchema?.fields || [];
+    const metadataFilterInterface = generateMetadataFilterInterface(metadataFields, 1);
+    const hasMetadataFilters = metadataFilterInterface && metadataFilterInterface !== '{}';
+    // Build the full filter interface
+    lines.push(`/**`);
+    lines.push(` * Typed filter interface for ${model.name}`);
+    lines.push(` * Supports filtering on data fields, nested objects, and metadata`);
+    lines.push(` */`);
+    lines.push(`export interface ${typeName}Filters {`);
+    // Add data fields section
+    if (dataFilterInterface !== '{}') {
+        lines.push(`  /** Filter on content/data fields */`);
+        lines.push(`  data?: ${dataFilterInterface}`);
+    }
+    // Add metadata fields section if available
+    if (hasMetadataFilters) {
+        lines.push(`  /** Filter on metadata fields (synced data, system fields) */`);
+        lines.push(`  metadata?: ${metadataFilterInterface}`);
+    }
+    // Add common record fields
+    lines.push(`  /** Filter on record-level fields */`);
+    lines.push(`  id?: TextFilter;`);
+    lines.push(`  naturalKey?: TextFilter;`);
+    lines.push(`  status?: SelectFilter<'DRAFT' | 'PUBLISHED' | 'ARCHIVED'>;`);
+    lines.push(`  createdAt?: DateFilter;`);
+    lines.push(`  updatedAt?: DateFilter;`);
+    lines.push(`}`);
+    lines.push('');
+    // Generate the buildFilters helper
+    lines.push(`/**`);
+    lines.push(` * Convert typed filters to API FilterInput array`);
+    lines.push(` * Handles nested objects by creating dot-notation field paths`);
+    lines.push(` */`);
+    lines.push(`export function build${typeName}Filters(filters: ${typeName}Filters): FilterInput[] {`);
+    lines.push(`  const result: FilterInput[] = [];`);
+    lines.push('');
+    lines.push(`  function processFilters(obj: Record<string, any>, prefix: string) {`);
+    lines.push(`    for (const [key, value] of Object.entries(obj)) {`);
+    lines.push(`      if (value === undefined || value === null) continue;`);
+    lines.push('');
+    lines.push(`      const fieldPath = prefix ? \`\${prefix}.\${key}\` : key;`);
+    lines.push('');
+    lines.push(`      // Check if this is a filter operator object`);
+    lines.push(`      if (isFilterOperator(value)) {`);
+    lines.push(`        // Convert each operator to a FilterInput`);
+    lines.push(`        for (const [op, opValue] of Object.entries(value)) {`);
+    lines.push(`          if (opValue !== undefined) {`);
+    lines.push(`            result.push({`);
+    lines.push(`              field: fieldPath,`);
+    lines.push(`              operator: op,`);
+    lines.push(`              value: opValue,`);
+    lines.push(`            });`);
+    lines.push(`          }`);
+    lines.push(`        }`);
+    lines.push(`      } else if (typeof value === 'object' && !Array.isArray(value)) {`);
+    lines.push(`        // Nested object - recurse`);
+    lines.push(`        processFilters(value, fieldPath);`);
+    lines.push(`      }`);
+    lines.push(`    }`);
+    lines.push(`  }`);
+    lines.push('');
+    lines.push(`  // Process data filters`);
+    lines.push(`  if (filters.data) {`);
+    lines.push(`    processFilters(filters.data, 'data');`);
+    lines.push(`  }`);
+    lines.push('');
+    lines.push(`  // Process metadata filters`);
+    lines.push(`  if (filters.metadata) {`);
+    lines.push(`    processFilters(filters.metadata, 'metadata');`);
+    lines.push(`  }`);
+    lines.push('');
+    lines.push(`  // Process record-level filters`);
+    lines.push(`  const recordFields = ['id', 'naturalKey', 'status', 'createdAt', 'updatedAt'];`);
+    lines.push(`  for (const field of recordFields) {`);
+    lines.push(`    const value = (filters as any)[field];`);
+    lines.push(`    if (value && isFilterOperator(value)) {`);
+    lines.push(`      for (const [op, opValue] of Object.entries(value)) {`);
+    lines.push(`        if (opValue !== undefined) {`);
+    lines.push(`          result.push({ field, operator: op, value: opValue });`);
+    lines.push(`        }`);
+    lines.push(`      }`);
+    lines.push(`    }`);
+    lines.push(`  }`);
+    lines.push('');
+    lines.push(`  return result;`);
+    lines.push(`}`);
+    lines.push('');
+    // Helper function to check if an object is a filter operator
+    lines.push(`/** Check if an object is a filter operator (has operator keys) */`);
+    lines.push(`function isFilterOperator(obj: unknown): boolean {`);
+    lines.push(`  if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) {`);
+    lines.push(`    return false;`);
+    lines.push(`  }`);
+    lines.push(`  const filterOps = [`);
+    lines.push(`    'eq', 'ne', 'gt', 'gte', 'lt', 'lte',`);
+    lines.push(`    'contains', 'startsWith', 'endsWith',`);
+    lines.push(`    'in', 'notIn', 'isNull',`);
+    lines.push(`    'containsAny', 'containsAll',`);
+    lines.push(`  ];`);
+    lines.push(`  return Object.keys(obj).some(key => filterOps.includes(key));`);
+    lines.push(`}`);
+    return lines.join('\n') + '\n';
+}
+/**
+ * Generate index file for filters
+ */
+export function generateFiltersIndex(models) {
+    const recordModels = models.filter((m) => m.modes.records);
+    let indexCode = `/**
+ * Typed Entity Filters
+ *
+ * Type-safe filter interfaces and builders for all entity models.
+ *
+ * @generated by UniformGen - DO NOT EDIT MANUALLY
+ */\n\n`;
+    // Re-export filter types from field-types
+    indexCode += `// Re-export base filter types\n`;
+    indexCode += `export type {\n`;
+    indexCode += `  TextFilter,\n`;
+    indexCode += `  NumberFilter,\n`;
+    indexCode += `  BooleanFilter,\n`;
+    indexCode += `  DateFilter,\n`;
+    indexCode += `  SelectFilter,\n`;
+    indexCode += `  MultiselectFilter,\n`;
+    indexCode += `  ReferenceFilter,\n`;
+    indexCode += `  FilterInput,\n`;
+    indexCode += `  SortInput,\n`;
+    indexCode += `} from '../types/field-types.js';\n\n`;
+    // Export each model's filters
+    for (const model of recordModels) {
+        const typeName = toPascalCase(model.key);
+        indexCode += `export {\n`;
+        indexCode += `  type ${typeName}Filters,\n`;
+        indexCode += `  build${typeName}Filters,\n`;
+        indexCode += `} from './${model.key}.js';\n`;
+    }
+    return indexCode;
+}

package/dist/generators/hooks/agnostic.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Agnostic Hooks Generator
+ *
+ * Generates framework-agnostic typed helper functions that parse
+ * the generic entity API responses into strongly typed data.
+ */
+import type { EntityModel } from '../../fetcher/fetch-schemas.js';
+/**
+ * Generate agnostic typed helpers for an entity model
+ */
+export declare function generateAgnosticHooks(model: EntityModel, _allModels: EntityModel[]): string;
+/**
+ * Generate index file for agnostic hooks
+ */
+export declare function generateAgnosticHooksIndex(models: EntityModel[]): string;
+//# sourceMappingURL=agnostic.d.ts.map

package/dist/generators/hooks/agnostic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agnostic.d.ts","sourceRoot":"","sources":["../../../src/generators/hooks/agnostic.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAuB,MAAM,gCAAgC,CAAC;AAoGvF;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,WAAW,EAClB,UAAU,EAAE,WAAW,EAAE,GACxB,MAAM,CAmIR;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,CAiCxE"}