@eide/uniformgen 0.1.0

package/dist/generators/types/data-models.js

@@ -0,0 +1,100 @@
+import { getFieldType, getRequiredImports, sanitizeFieldName, toPascalCase, } from '../../utils/field-mapping.js';
+/**
+ * Generate TypeScript types for a data model
+ */
+export function generateDataModelTypes(model, _useUnknownForJSON) {
+    const typeName = toPascalCase(model.handle);
+    const fields = model.fields || [];
+    // Get required imports
+    const imports = getRequiredImports(fields);
+    const importStatements = imports.size > 0
+        ? `import type { ${Array.from(imports)
+            .map((i) => {
+            if (i === 'scalars') {
+                return Array.from(new Set(fields.map((f) => getFieldType(f, 'output'))))
+                    .filter((t) => ![
+                    'string',
+                    'number',
+                    'boolean',
+                    'Date',
+                    'unknown',
+                ].includes(t) && !t.includes('[]'))
+                    .join(', ');
+            }
+            return '';
+        })
+            .filter(Boolean)
+            .join(', ')} } from '../scalars.js';\n\n`
+        : '';
+    // Generate main interface
+    let interfaceCode = `/**
+ * ${model.name}${model.description ? `\n * ${model.description}` : ''}
+ *
+ * @generated from data model schema '${model.handle}'
+ */
+export interface ${typeName} {
+  id: string;\n`;
+    // Add fields
+    for (const field of fields) {
+        const fieldName = sanitizeFieldName(field.key);
+        const fieldType = getFieldType(field, 'output');
+        const optional = field.required ? '' : '?';
+        const comment = field.helpText ? `  /** ${field.helpText} */\n` : '';
+        interfaceCode += comment;
+        interfaceCode += `  ${fieldName}${optional}: ${fieldType};\n`;
+    }
+    // Add system fields
+    interfaceCode += `
+  // System fields
+  createdAt: Date;
+  updatedAt: Date;
+}\n\n`;
+    // Generate input type
+    interfaceCode += `/**
+ * Input type for creating/updating ${model.name}
+ */
+export interface ${typeName}Input {\n`;
+    for (const field of fields) {
+        const fieldName = sanitizeFieldName(field.key);
+        const fieldType = getFieldType(field, 'input');
+        const optional = field.required ? '' : '?';
+        interfaceCode += `  ${fieldName}${optional}: ${fieldType};\n`;
+    }
+    interfaceCode += '}\n\n';
+    // Generate translations type if any fields are translatable
+    const translatableFields = fields.filter((f) => f.isTranslatable);
+    if (translatableFields.length > 0) {
+        interfaceCode += `/**
+ * Translatable fields for ${model.name}
+ */
+export interface ${typeName}Translations {\n`;
+        for (const field of translatableFields) {
+            const fieldName = sanitizeFieldName(field.key);
+            const fieldType = getFieldType(field, 'output');
+            interfaceCode += `  ${fieldName}?: Record<string, ${fieldType}>; // locale -> content\n`;
+        }
+        interfaceCode += '}\n';
+    }
+    return importStatements + interfaceCode;
+}
+/**
+ * Generate index file for data models
+ */
+export function generateDataModelsIndex(models) {
+    let indexCode = `/**
+ * Data Models - Generated types
+ *
+ * @generated by UniformGen - DO NOT EDIT MANUALLY
+ */\n\n`;
+    for (const model of models) {
+        const typeName = toPascalCase(model.handle);
+        indexCode += `export type { ${typeName}, ${typeName}Input`;
+        // Add translations export if any fields are translatable
+        const hasTranslations = model.fields?.some((f) => f.isTranslatable);
+        if (hasTranslations) {
+            indexCode += `, ${typeName}Translations`;
+        }
+        indexCode += ` } from './${model.handle}.js';\n`;
+    }
+    return indexCode;
+}

package/dist/generators/types/entity-models.d.ts

@@ -0,0 +1,13 @@
+import type { EntityModel } from '../../fetcher/fetch-schemas.js';
+/**
+ * Generate TypeScript code for an entity model
+ *
+ * For models with records mode: generates config object + data interface
+ * For inline-only models: generates only data interface (no config)
+ */
+export declare function generateEntityModelTypes(model: EntityModel, allModels: EntityModel[]): string;
+/**
+ * Generate index file for entity models
+ */
+export declare function generateEntityModelsIndex(models: EntityModel[]): string;
+//# sourceMappingURL=entity-models.d.ts.map

package/dist/generators/types/entity-models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-models.d.ts","sourceRoot":"","sources":["../../../src/generators/types/entity-models.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAe,MAAM,gCAAgC,CAAC;AA+B/E;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,WAAW,EAClB,SAAS,EAAE,WAAW,EAAE,GACvB,MAAM,CAiCR;AA6ND;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,CAsBvE"}

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

@@ -0,0 +1,241 @@
+import { getFieldType, getInlineSchemaReferences, generateFieldDef, sanitizeFieldName, toPascalCase, toCamelCase, FIELD_TYPE_MAPPING, } from '../../utils/field-mapping.js';
+/**
+ * Check if model is inline-only (no records mode)
+ */
+function isInlineOnlyModel(model) {
+    return model.modes.inline && !model.modes.records;
+}
+/**
+ * Get the mode string for config
+ */
+function getModelMode(model) {
+    if (model.modes.inline && model.modes.records) {
+        return 'both';
+    }
+    if (model.modes.inline) {
+        return 'inline';
+    }
+    return 'records';
+}
+/**
+ * Generate TypeScript code for an entity model
+ *
+ * For models with records mode: generates config object + data interface
+ * For inline-only models: generates only data interface (no config)
+ */
+export function generateEntityModelTypes(model, allModels) {
+    const typeName = toPascalCase(model.key);
+    const configName = toCamelCase(model.key) + 'Config';
+    const fields = model.fields || [];
+    // Get field type imports
+    const fieldTypeImports = getFieldTypeImportsForFields(fields);
+    // Get inline schema references
+    const inlineSchemaRefs = getInlineSchemaReferences(fields);
+    // Build imports
+    const importStatements = buildImportStatements(model, fieldTypeImports, inlineSchemaRefs, allModels);
+    let code = importStatements;
+    // For inline-only models, only generate the data interface
+    if (isInlineOnlyModel(model)) {
+        code += generateDataInterface(model, fields, typeName, allModels);
+        return code;
+    }
+    // For models with records mode, generate both config and data interface
+    code += generateConfigObject(model, fields, configName);
+    code += '\n';
+    code += generateDataInterface(model, fields, typeName + 'Data', allModels);
+    return code;
+}
+/**
+ * Build import statements for the generated file
+ */
+function buildImportStatements(model, fieldTypeImports, inlineSchemaRefs, allModels) {
+    const imports = [];
+    // Config import (only for non-inline-only models)
+    if (!isInlineOnlyModel(model)) {
+        imports.push("import type { EntityModelConfig } from '../config.js';");
+    }
+    // Field type value imports
+    if (fieldTypeImports.size > 0) {
+        const types = Array.from(fieldTypeImports).sort().join(', ');
+        imports.push(`import type { ${types} } from '../field-types.js';`);
+    }
+    // Inline schema imports
+    for (const refKey of inlineSchemaRefs) {
+        const refModel = allModels.find((m) => m.key === refKey);
+        if (refModel) {
+            const refTypeName = isInlineOnlyModel(refModel)
+                ? toPascalCase(refKey)
+                : toPascalCase(refKey) + 'Data';
+            imports.push(`import type { ${refTypeName} } from './${refKey}.js';`);
+        }
+    }
+    if (imports.length > 0) {
+        return imports.join('\n') + '\n\n';
+    }
+    return '';
+}
+/**
+ * Generate the config object for an entity model
+ */
+function generateConfigObject(model, fields, configName) {
+    const lines = [];
+    // JSDoc comment
+    lines.push('/**');
+    lines.push(` * ${model.name} Configuration`);
+    if (model.description) {
+        lines.push(` * ${model.description}`);
+    }
+    lines.push(` *`);
+    lines.push(` * @generated from entity model '${model.key}'`);
+    lines.push(' */');
+    // Config object
+    lines.push(`export const ${configName} = {`);
+    lines.push(`  key: '${model.key}',`);
+    lines.push(`  name: '${model.name.replace(/'/g, "\\'")}',`);
+    if (model.description) {
+        lines.push(`  description: '${model.description.replace(/'/g, "\\'")}',`);
+    }
+    // Feature flags derived from tier
+    lines.push('');
+    lines.push('  // Feature flags');
+    lines.push(`  versions: ${model.tier >= 2},`);
+    lines.push(`  variants: ${model.tier >= 3},`);
+    lines.push(`  customFields: ${!(model.isInfrastructure ?? false)},`);
+    // Usage mode
+    lines.push('');
+    lines.push('  // Usage mode');
+    lines.push(`  mode: '${getModelMode(model)}',`);
+    lines.push(`  publicApi: ${model.modes.publicApi ?? false},`);
+    lines.push(`  editorMode: '${model.editorMode ?? 'flat'}',`);
+    // Pages configuration (routing, default template, sitemap)
+    if (model.pages) {
+        lines.push('');
+        lines.push('  // Pages configuration');
+        const pagesParts = [];
+        pagesParts.push(`enabled: ${model.pages.enabled}`);
+        if (model.pages.defaultTemplate) {
+            pagesParts.push(`defaultTemplate: '${model.pages.defaultTemplate.naturalKey}'`);
+        }
+        if (model.pages.sitemap) {
+            const sitemapParts = [];
+            if (model.pages.sitemap.changefreq) {
+                sitemapParts.push(`changefreq: '${model.pages.sitemap.changefreq}'`);
+            }
+            if (model.pages.sitemap.priority !== undefined) {
+                sitemapParts.push(`priority: ${model.pages.sitemap.priority}`);
+            }
+            if (sitemapParts.length > 0) {
+                pagesParts.push(`sitemap: { ${sitemapParts.join(', ')} }`);
+            }
+        }
+        lines.push(`  pages: { ${pagesParts.join(', ')} },`);
+    }
+    // Hooks
+    if (model.hooks && Object.keys(model.hooks).length > 0) {
+        lines.push('');
+        lines.push('  // Lifecycle hooks');
+        lines.push(`  hooks: ${JSON.stringify(model.hooks, null, 4).replace(/\n/g, '\n  ')},`);
+    }
+    else {
+        lines.push('');
+        lines.push('  // Lifecycle hooks');
+        lines.push('  hooks: {},');
+    }
+    // Field definitions
+    lines.push('');
+    lines.push('  // Field definitions');
+    if (fields.length === 0) {
+        lines.push('  fieldDefs: [],');
+    }
+    else {
+        lines.push('  fieldDefs: [');
+        for (const field of fields) {
+            lines.push(`    ${generateFieldDef(field)},`);
+        }
+        lines.push('  ],');
+    }
+    lines.push('} as const satisfies EntityModelConfig;');
+    return lines.join('\n') + '\n';
+}
+/**
+ * Generate the data interface for field values
+ */
+function generateDataInterface(model, fields, interfaceName, allModels) {
+    const lines = [];
+    // JSDoc comment
+    lines.push('/**');
+    lines.push(` * ${model.name} Data`);
+    lines.push(` * Field values only - no system fields`);
+    lines.push(` *`);
+    lines.push(` * @generated from entity model '${model.key}'`);
+    lines.push(' */');
+    lines.push(`export interface ${interfaceName} {`);
+    for (const field of fields) {
+        const fieldName = sanitizeFieldName(field.key);
+        let fieldType = getFieldType(field, 'output');
+        // Adjust type name for inline schema references to models with records mode
+        const refModel = allModels.find((m) => m.key === field.type);
+        if (refModel && !isInlineOnlyModel(refModel)) {
+            // Model has records mode, so use PascalCaseData instead of just PascalCase
+            fieldType = toPascalCase(field.type) + 'Data';
+        }
+        // Also handle list/tree itemType
+        if ((field.type === 'list' || field.type === 'tree') &&
+            field.options?.itemType) {
+            const itemRefModel = allModels.find((m) => m.key === field.options.itemType);
+            if (itemRefModel && !isInlineOnlyModel(itemRefModel)) {
+                fieldType = toPascalCase(field.options.itemType) + 'Data[]';
+            }
+        }
+        const optional = field.required ? '' : '?';
+        const comment = field.helpText ? `  /** ${field.helpText} */\n` : '';
+        lines.push(comment + `  ${fieldName}${optional}: ${fieldType};`);
+    }
+    lines.push('}');
+    return lines.join('\n') + '\n';
+}
+/**
+ * Get field type value imports needed for a set of fields
+ */
+function getFieldTypeImportsForFields(fields) {
+    const imports = new Set();
+    for (const field of fields) {
+        const mapping = FIELD_TYPE_MAPPING[field.type];
+        if (mapping?.needsImport === 'field-types') {
+            imports.add(mapping.outputType);
+        }
+        // Check list/tree itemType
+        if ((field.type === 'list' || field.type === 'tree') &&
+            field.options?.itemType) {
+            const itemMapping = FIELD_TYPE_MAPPING[field.options.itemType];
+            if (itemMapping?.needsImport === 'field-types') {
+                imports.add(itemMapping.outputType);
+            }
+        }
+    }
+    return imports;
+}
+/**
+ * Generate index file for entity models
+ */
+export function generateEntityModelsIndex(models) {
+    let indexCode = `/**
+ * Entity Models - Generated types and configs
+ *
+ * @generated by UniformGen - DO NOT EDIT MANUALLY
+ */\n\n`;
+    for (const model of models) {
+        const typeName = toPascalCase(model.key);
+        const configName = toCamelCase(model.key) + 'Config';
+        if (isInlineOnlyModel(model)) {
+            // Inline-only: export only the data type
+            indexCode += `export type { ${typeName} } from './${model.key}.js';\n`;
+        }
+        else {
+            // Records mode: export config and data type
+            indexCode += `export { ${configName} } from './${model.key}.js';\n`;
+            indexCode += `export type { ${typeName}Data } from './${model.key}.js';\n`;
+        }
+    }
+    return indexCode;
+}

package/dist/generators/types/field-types.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Generates the field-types.ts file with:
+ * - Value types for each field type (what the data looks like)
+ * - Field definition types (how to define fields in config)
+ *
+ * @generated by UniformGen
+ */
+export declare function generateFieldTypesFile(): string;
+//# sourceMappingURL=field-types.d.ts.map

package/dist/generators/types/field-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field-types.d.ts","sourceRoot":"","sources":["../../../src/generators/types/field-types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,wBAAgB,sBAAsB,IAAI,MAAM,CAmoB/C"}