@eide/uniformgen 0.1.0

package/dist/generators/admin/types.js

@@ -0,0 +1,254 @@
+/**
+ * Admin Types Generator
+ *
+ * Generates TypeScript types for administration layer:
+ * - Record types with variants
+ * - Version types for history
+ * - Filter and input types
+ *
+ * @generated by UniformGen
+ */
+import { toPascalCase, sanitizeFieldName } from '../../utils/field-mapping.js';
+/**
+ * Map metadata field type to TypeScript type
+ */
+function getMetadataValueType(fieldType) {
+    switch (fieldType) {
+        case 'string':
+            return 'string';
+        case 'number':
+            return 'number';
+        case 'boolean':
+            return 'boolean';
+        case 'date':
+            return 'string'; // ISO date string
+        case 'array':
+            return 'unknown[]';
+        case 'object':
+            return 'Record<string, unknown>';
+        default:
+            return 'unknown';
+    }
+}
+/**
+ * Build a nested TypeScript interface from dot-notation paths
+ */
+function buildNestedMetadataType(fields, depth = 0) {
+    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];
+            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 = [];
+    for (const field of directFields) {
+        const valueType = getMetadataValueType(field.type);
+        const fieldName = sanitizeFieldName(field.key);
+        const optional = field.required ? '' : '?';
+        lines.push(`${indent}${fieldName}${optional}: ${valueType};`);
+    }
+    for (const [groupName, groupFields] of groups) {
+        const nestedType = buildNestedMetadataType(groupFields, depth + 1);
+        if (nestedType !== '{}') {
+            const fieldName = sanitizeFieldName(groupName);
+            lines.push(`${indent}${fieldName}?: ${nestedType}`);
+        }
+    }
+    if (lines.length === 0) {
+        return '{}';
+    }
+    const closeIndent = '  '.repeat(depth);
+    return `{\n${lines.join('\n')}\n${closeIndent}}`;
+}
+/**
+ * Generate metadata type for a model
+ */
+export function generateMetadataType(model) {
+    const metadataFields = model.metadataSchema?.fields;
+    if (!metadataFields || metadataFields.length === 0) {
+        return null;
+    }
+    return buildNestedMetadataType(metadataFields, 0);
+}
+/**
+ * Check if model is inline-only (no records mode)
+ */
+export function isInlineOnlyModel(model) {
+    return model.modes.inline && !model.modes.records;
+}
+/**
+ * Generate admin types for a model
+ */
+export function generateAdminTypes(model, _allModels) {
+    // Skip inline-only models - they don't have standalone records
+    if (isInlineOnlyModel(model)) {
+        return '';
+    }
+    const typeName = toPascalCase(model.key);
+    const dataTypeName = `${typeName}Data`;
+    const metadataType = generateMetadataType(model);
+    const metadataTypeName = `${typeName}Metadata`;
+    const lines = [];
+    // File header
+    lines.push(`/**`);
+    lines.push(` * ${model.name} - Admin Types`);
+    lines.push(` *`);
+    lines.push(` * Types for administration layer (CRUD operations, versioning).`);
+    lines.push(` *`);
+    lines.push(` * @generated by UniformGen - DO NOT EDIT MANUALLY`);
+    lines.push(` */`);
+    lines.push('');
+    // Imports
+    lines.push(`import type { ${dataTypeName} } from '../../types/models/${model.key}.js';`);
+    lines.push('');
+    // Generate metadata type if model has metadataSchema
+    if (metadataType) {
+        lines.push(`/** Typed metadata for ${model.name} */`);
+        lines.push(`export interface ${metadataTypeName} ${metadataType}`);
+        lines.push('');
+    }
+    // Version type
+    lines.push(`/** ${model.name} version (point-in-time snapshot) */`);
+    lines.push(`export interface ${typeName}Version {`);
+    lines.push(`  id: string;`);
+    lines.push(`  variantId: string;`);
+    lines.push(`  versionNumber: number;`);
+    lines.push(`  content: ${dataTypeName};`);
+    lines.push(`  isPublished: boolean;`);
+    lines.push(`  createdAt: string;`);
+    lines.push(`  createdBy?: string;`);
+    lines.push(`}`);
+    lines.push('');
+    // Variant type
+    lines.push(`/** ${model.name} variant (market/device/locale specific) */`);
+    lines.push(`export interface ${typeName}Variant {`);
+    lines.push(`  id: string;`);
+    lines.push(`  variantKey: string;`);
+    lines.push(`  catalogKey: string | null;`);
+    lines.push(`  currentVersion?: ${typeName}Version;`);
+    lines.push(`  publishedVersion?: ${typeName}Version;`);
+    lines.push(`  versionCount: number;`);
+    lines.push(`}`);
+    lines.push('');
+    // Record type (for list views)
+    lines.push(`/** ${model.name} record (list view) */`);
+    lines.push(`export interface ${typeName}Record {`);
+    lines.push(`  id: string;`);
+    lines.push(`  modelKey: '${model.key}';`);
+    lines.push(`  naturalKey?: string;`);
+    lines.push(`  data: ${dataTypeName};`);
+    if (metadataType) {
+        lines.push(`  metadata?: ${metadataTypeName};`);
+    }
+    else {
+        lines.push(`  metadata?: Record<string, unknown>;`);
+    }
+    lines.push(`  versionNumber: number;`);
+    lines.push(`  publishedVersionNumber?: number;`);
+    lines.push(`  status: 'DRAFT' | 'PUBLISHED' | 'ARCHIVED';`);
+    lines.push(`  createdAt: string;`);
+    lines.push(`  updatedAt: string;`);
+    lines.push(`}`);
+    lines.push('');
+    // Record with variants type (for detail views)
+    lines.push(`/** ${model.name} record with variants (detail view) */`);
+    lines.push(`export interface ${typeName}RecordWithVariants extends ${typeName}Record {`);
+    lines.push(`  variants: ${typeName}Variant[];`);
+    lines.push(`}`);
+    lines.push('');
+    // Filter input type
+    lines.push(`/** Filter input for ${model.name} queries */`);
+    lines.push(`export interface ${typeName}FilterInput {`);
+    lines.push(`  search?: string;`);
+    lines.push(`  status?: 'DRAFT' | 'PUBLISHED' | 'ARCHIVED';`);
+    lines.push(`  naturalKey?: string;`);
+    lines.push(`  createdAfter?: string;`);
+    lines.push(`  createdBefore?: string;`);
+    lines.push(`  updatedAfter?: string;`);
+    lines.push(`  updatedBefore?: string;`);
+    lines.push(`}`);
+    lines.push('');
+    // Create input type
+    lines.push(`/** Input for creating a ${model.name} record */`);
+    lines.push(`export interface Create${typeName}Input {`);
+    lines.push(`  naturalKey?: string;`);
+    lines.push(`  data: ${dataTypeName};`);
+    if (metadataType) {
+        lines.push(`  metadata?: ${metadataTypeName};`);
+    }
+    else {
+        lines.push(`  metadata?: Record<string, unknown>;`);
+    }
+    lines.push(`}`);
+    lines.push('');
+    // Update input type
+    lines.push(`/** Input for updating a ${model.name} record */`);
+    lines.push(`export interface Update${typeName}Input {`);
+    lines.push(`  naturalKey?: string;`);
+    if (metadataType) {
+        lines.push(`  metadata?: Partial<${metadataTypeName}>;`);
+    }
+    else {
+        lines.push(`  metadata?: Record<string, unknown>;`);
+    }
+    lines.push(`}`);
+    lines.push('');
+    // Save content input type
+    lines.push(`/** Input for saving ${model.name} content (creates new version) */`);
+    lines.push(`export interface Save${typeName}ContentInput {`);
+    lines.push(`  variantId: string;`);
+    lines.push(`  content: ${dataTypeName};`);
+    lines.push(`}`);
+    lines.push('');
+    // Save content result type
+    lines.push(`/** Result of saving ${model.name} content */`);
+    lines.push(`export interface Save${typeName}ContentResult {`);
+    lines.push(`  variantId: string;`);
+    lines.push(`  versionId: string;`);
+    lines.push(`  versionNumber: number;`);
+    lines.push(`}`);
+    return lines.join('\n') + '\n';
+}
+/**
+ * Generate index file for admin types
+ */
+export function generateAdminTypesIndex(models) {
+    const recordModels = models.filter((m) => m.modes.records);
+    let indexCode = `/**
+ * Admin Types
+ *
+ * Types for administration layer (CRUD operations, versioning).
+ *
+ * @generated by UniformGen - DO NOT EDIT MANUALLY
+ */\n\n`;
+    for (const model of recordModels) {
+        const typeName = toPascalCase(model.key);
+        const hasMetadata = model.metadataSchema?.fields && model.metadataSchema.fields.length > 0;
+        indexCode += `export type {\n`;
+        indexCode += `  ${typeName}Record,\n`;
+        indexCode += `  ${typeName}RecordWithVariants,\n`;
+        indexCode += `  ${typeName}Variant,\n`;
+        indexCode += `  ${typeName}Version,\n`;
+        indexCode += `  ${typeName}FilterInput,\n`;
+        indexCode += `  Create${typeName}Input,\n`;
+        indexCode += `  Update${typeName}Input,\n`;
+        indexCode += `  Save${typeName}ContentInput,\n`;
+        indexCode += `  Save${typeName}ContentResult,\n`;
+        if (hasMetadata) {
+            indexCode += `  ${typeName}Metadata,\n`;
+        }
+        indexCode += `} from './${model.key}.js';\n`;
+    }
+    return indexCode;
+}

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

@@ -0,0 +1,29 @@
+/**
+ * CMS Generator
+ *
+ * Generates typed hooks/functions for CMS route resolution layer:
+ * - resolveRoute for URL-based entity resolution
+ * - Template, zone, and layout resolution
+ * - Breadcrumbs and grid configuration
+ *
+ * Only generates when there are models with cms.enabled = true.
+ *
+ * @generated by UniformGen
+ */
+import type { EntityModel } from '../../fetcher/fetch-schemas.js';
+export { generateCmsTypes } from './types.js';
+export { hasRoutingEnabled, getRoutableModels, generateResolveRouteReact, generateResolveRouteRemix, } from './route.js';
+/**
+ * Check if CMS generation is needed
+ * Returns true if any model has cms.enabled = true
+ */
+export declare function shouldGenerateCms(models: EntityModel[]): boolean;
+/**
+ * Generate CMS index file for React
+ */
+export declare function generateCmsIndexReact(models: EntityModel[]): string;
+/**
+ * Generate CMS index file for Remix/Hydrogen
+ */
+export declare function generateCmsIndexRemix(models: EntityModel[]): string;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/generators/cms/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAElE,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,EACL,iBAAiB,EACjB,iBAAiB,EACjB,yBAAyB,EACzB,yBAAyB,GAC1B,MAAM,YAAY,CAAC;AAEpB;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,OAAO,CAEhE;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,CAkDnE;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,CAmDnE"}

package/dist/generators/cms/index.js

@@ -0,0 +1,126 @@
+/**
+ * CMS Generator
+ *
+ * Generates typed hooks/functions for CMS route resolution layer:
+ * - resolveRoute for URL-based entity resolution
+ * - Template, zone, and layout resolution
+ * - Breadcrumbs and grid configuration
+ *
+ * Only generates when there are models with cms.enabled = true.
+ *
+ * @generated by UniformGen
+ */
+export { generateCmsTypes } from './types.js';
+export { hasRoutingEnabled, getRoutableModels, generateResolveRouteReact, generateResolveRouteRemix, } from './route.js';
+/**
+ * Check if CMS generation is needed
+ * Returns true if any model has cms.enabled = true
+ */
+export function shouldGenerateCms(models) {
+    return models.some(m => m.pages?.enabled === true);
+}
+/**
+ * Generate CMS index file for React
+ */
+export function generateCmsIndexReact(models) {
+    const routableModels = models.filter(m => m.pages?.enabled === true);
+    if (routableModels.length === 0) {
+        return `/**
+ * CMS Resolution
+ *
+ * No routable models found. CMS resolution is not available.
+ *
+ * @generated by UniformGen - DO NOT EDIT MANUALLY
+ */
+
+export {};
+`;
+    }
+    return `/**
+ * CMS Resolution
+ *
+ * React hooks for CMS route resolution with templates, zones, and layouts.
+ *
+ * @generated by UniformGen - DO NOT EDIT MANUALLY
+ */
+
+// Route resolution hook
+export {
+  useResolveRoute,
+  ROUTABLE_MODELS,
+  type RoutableModelKey,
+} from './route.js';
+
+// Types
+export type {
+  ResolvedRoute,
+  ResolvedRecord,
+  ResolvedVariant,
+  ResolvedContent,
+  ResolvedField,
+  ResolvedTemplateRef,
+  ResolutionContext,
+  FieldLayout,
+  LayoutPosition,
+  FieldSource,
+  GridConfig,
+  Breadcrumb,
+  BreadcrumbType,
+  VariantContext,
+  ReferenceResolutionOptions,
+} from './types.js';
+`;
+}
+/**
+ * Generate CMS index file for Remix/Hydrogen
+ */
+export function generateCmsIndexRemix(models) {
+    const routableModels = models.filter(m => m.pages?.enabled === true);
+    if (routableModels.length === 0) {
+        return `/**
+ * CMS Resolution
+ *
+ * No routable models found. CMS resolution is not available.
+ *
+ * @generated by UniformGen - DO NOT EDIT MANUALLY
+ */
+
+export {};
+`;
+    }
+    return `/**
+ * CMS Resolution
+ *
+ * Server-side functions for CMS route resolution with templates, zones, and layouts.
+ *
+ * @generated by UniformGen - DO NOT EDIT MANUALLY
+ */
+
+// Route resolution function
+export {
+  resolveRoute,
+  ROUTABLE_MODELS,
+  type RoutableModelKey,
+  type GraphQLClient,
+} from './route.js';
+
+// Types
+export type {
+  ResolvedRoute,
+  ResolvedRecord,
+  ResolvedVariant,
+  ResolvedContent,
+  ResolvedField,
+  ResolvedTemplateRef,
+  ResolutionContext,
+  FieldLayout,
+  LayoutPosition,
+  FieldSource,
+  GridConfig,
+  Breadcrumb,
+  BreadcrumbType,
+  VariantContext,
+  ReferenceResolutionOptions,
+} from './types.js';
+`;
+}

package/dist/generators/cms/route.d.ts

@@ -0,0 +1,27 @@
+/**
+ * CMS Route Resolution Generator
+ *
+ * Generates the resolveRoute hook/function for CMS frontends.
+ * Only generated when there are models with cms.enabled = true.
+ *
+ * @generated by UniformGen
+ */
+import type { EntityModel } from '../../fetcher/fetch-schemas.js';
+/**
+ * Check if a model has CMS enabled (cms.enabled in extensions)
+ * Note: The `pages` property on EntityModel is extracted from extensions.cms
+ */
+export declare function hasRoutingEnabled(model: EntityModel): boolean;
+/**
+ * Get all routable models (models with cms.enabled = true)
+ */
+export declare function getRoutableModels(models: EntityModel[]): EntityModel[];
+/**
+ * Generate React resolveRoute hook
+ */
+export declare function generateResolveRouteReact(routableModels: EntityModel[]): string;
+/**
+ * Generate Remix/Hydrogen resolveRoute function
+ */
+export declare function generateResolveRouteRemix(routableModels: EntityModel[]): string;
+//# sourceMappingURL=route.d.ts.map

package/dist/generators/cms/route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../src/generators/cms/route.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAElE;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAE7D;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,WAAW,EAAE,CAEtE;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,cAAc,EAAE,WAAW,EAAE,GAAG,MAAM,CA2L/E;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,cAAc,EAAE,WAAW,EAAE,GAAG,MAAM,CAmM/E"}