@eide/uniformgen 0.1.0

package/dist/utils/field-mapping.js

@@ -0,0 +1,334 @@
+/**
+ * Maps EIDE field types to TypeScript types
+ * Based on the field type mapping table in uniformgen-typesafe-entities.md
+ */
+/**
+ * Primitive field types that are built-in
+ * Based on the current field type registry in packages/platform/src/entities/field-types/registry.ts
+ */
+export const PRIMITIVE_FIELD_TYPES = new Set([
+    // Basic
+    'text',
+    'richtext',
+    'number',
+    'boolean',
+    // Validated (use text primitive with validation)
+    'email',
+    'phone',
+    'url',
+    // DateTime
+    'date',
+    // Media
+    'image',
+    'video',
+    'file',
+    // Financial
+    'currency',
+    // Choices
+    'select',
+    'multiselect',
+    // Complex
+    'json',
+    'list',
+    'tree',
+    // References
+    'entity-reference',
+    // Navigation
+    'link',
+    // Styling
+    'design-system-style',
+]);
+/**
+ * Check if a field type is a primitive (built-in) type
+ */
+export function isPrimitiveFieldType(type) {
+    return PRIMITIVE_FIELD_TYPES.has(type);
+}
+/**
+ * Field type to TypeScript type mapping
+ * Based on the current field type registry in packages/platform/src/entities/field-types/registry.ts
+ */
+export const FIELD_TYPE_MAPPING = {
+    // Basic types
+    text: {
+        outputType: 'string',
+        inputType: 'string',
+    },
+    richtext: {
+        outputType: 'RichtextValue',
+        inputType: 'RichtextValue',
+        needsImport: 'field-types',
+    },
+    number: {
+        outputType: 'number',
+        inputType: 'number',
+    },
+    boolean: {
+        outputType: 'boolean',
+        inputType: 'boolean',
+    },
+    // Validated types (use text primitive with validation)
+    email: {
+        outputType: 'string',
+        inputType: 'string',
+    },
+    phone: {
+        outputType: 'string',
+        inputType: 'string',
+    },
+    url: {
+        outputType: 'string',
+        inputType: 'string',
+    },
+    // DateTime
+    date: {
+        outputType: 'Date',
+        inputType: 'string', // ISO date string
+    },
+    // Media types
+    image: {
+        outputType: 'ImageValue',
+        inputType: 'string', // Image ID
+        needsImport: 'field-types',
+    },
+    video: {
+        outputType: 'VideoValue',
+        inputType: 'string', // Video ID
+        needsImport: 'field-types',
+    },
+    file: {
+        outputType: 'FileValue',
+        inputType: 'string', // File ID
+        needsImport: 'field-types',
+    },
+    // Financial
+    currency: {
+        outputType: 'CurrencyValue',
+        inputType: 'CurrencyValue',
+        needsImport: 'field-types',
+    },
+    // Choice types
+    select: {
+        outputType: 'string', // Can be union type if choices provided
+        inputType: 'string',
+    },
+    multiselect: {
+        outputType: 'string[]',
+        inputType: 'string[]',
+    },
+    // Complex types
+    json: {
+        outputType: 'unknown',
+        inputType: 'unknown',
+    },
+    list: {
+        outputType: 'unknown[]', // Type depends on itemType
+        inputType: 'unknown[]',
+    },
+    tree: {
+        outputType: 'unknown[]', // Hierarchical array
+        inputType: 'unknown[]',
+    },
+    // References
+    'entity-reference': {
+        outputType: 'ReferenceValue',
+        inputType: 'ReferenceValue',
+        needsImport: 'field-types',
+    },
+    // Navigation
+    link: {
+        outputType: 'LinkValue',
+        inputType: 'LinkValue',
+        needsImport: 'field-types',
+    },
+    // Styling
+    'design-system-style': {
+        outputType: 'Record<string, string>',
+        inputType: 'Record<string, string>',
+    },
+};
+/**
+ * Get TypeScript type for a field
+ */
+export function getFieldType(field, mode = 'output') {
+    const mapping = FIELD_TYPE_MAPPING[field.type];
+    // If not a primitive type, it's an inline schema reference
+    if (!mapping) {
+        if (isPrimitiveFieldType(field.type)) {
+            console.warn(`Unknown field type: ${field.type}, defaulting to 'unknown'`);
+            return 'unknown';
+        }
+        // Return PascalCase type name for inline schema reference
+        return toPascalCase(field.type);
+    }
+    let tsType = mode === 'output' ? mapping.outputType : mapping.inputType;
+    // Handle select with choices (create union type)
+    if (field.type === 'select' && field.options?.options) {
+        const options = field.options.options;
+        if (options.length > 0) {
+            const values = options.map((o) => `'${o.value}'`).join(' | ');
+            tsType = values;
+        }
+    }
+    // Handle multiselect with choices (create union type array)
+    if (field.type === 'multiselect' && field.options?.options) {
+        const options = field.options.options;
+        if (options.length > 0) {
+            const values = options.map((o) => `'${o.value}'`).join(' | ');
+            tsType = `(${values})[]`;
+        }
+    }
+    // Handle list with itemType
+    if ((field.type === 'list' || field.type === 'tree') && field.options?.itemType) {
+        const itemType = field.options.itemType;
+        const itemMapping = FIELD_TYPE_MAPPING[itemType];
+        if (itemMapping) {
+            const itemTsType = mode === 'output' ? itemMapping.outputType : itemMapping.inputType;
+            tsType = `${itemTsType}[]`;
+        }
+        else if (!isPrimitiveFieldType(itemType)) {
+            // Inline schema reference
+            tsType = `${toPascalCase(itemType)}[]`;
+        }
+    }
+    return tsType;
+}
+/**
+ * Get all imports needed for a set of fields
+ */
+export function getRequiredImports(fields) {
+    const imports = new Set();
+    for (const field of fields) {
+        const mapping = FIELD_TYPE_MAPPING[field.type];
+        if (mapping?.needsImport) {
+            imports.add(mapping.needsImport);
+        }
+        // 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) {
+                imports.add(itemMapping.needsImport);
+            }
+        }
+    }
+    return imports;
+}
+/**
+ * Get all inline schema references from fields
+ * Returns the keys of entity models that are used as field types
+ */
+export function getInlineSchemaReferences(fields) {
+    const references = new Set();
+    for (const field of fields) {
+        // Check if field type is an inline schema reference
+        if (!isPrimitiveFieldType(field.type)) {
+            references.add(field.type);
+        }
+        // Check list/tree itemType for inline schema references
+        if ((field.type === 'list' || field.type === 'tree') && field.options?.itemType) {
+            const itemType = field.options.itemType;
+            if (!isPrimitiveFieldType(itemType)) {
+                references.add(itemType);
+            }
+        }
+    }
+    return references;
+}
+/**
+ * Convert field ID to camelCase
+ */
+export function toCamelCase(str) {
+    return str.replace(/[-_]([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+/**
+ * Convert field ID to PascalCase
+ */
+export function toPascalCase(str) {
+    const camel = toCamelCase(str);
+    return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+/**
+ * Sanitize field name for TypeScript
+ * Replaces special characters and spaces with underscores.
+ * Prefixes with underscore if name starts with a number.
+ */
+export function sanitizeFieldName(name) {
+    // Replace all non-alphanumeric and non-underscore characters with underscores
+    let sanitized = name.replace(/[^a-zA-Z0-9_]/g, '_');
+    // If starts with a number, prefix with underscore
+    if (/^[0-9]/.test(sanitized)) {
+        sanitized = '_' + sanitized;
+    }
+    return sanitized;
+}
+/**
+ * Generate a strongly-typed field definition object string
+ * Returns a string that can be used in generated TypeScript code
+ */
+export function generateFieldDef(field) {
+    const parts = [];
+    // Required properties
+    parts.push(`key: '${field.key}'`);
+    parts.push(`type: '${field.type}'`);
+    parts.push(`label: '${field.label.replace(/'/g, "\\'")}'`);
+    // Optional properties
+    if (field.required) {
+        parts.push('required: true');
+    }
+    if (field.helpText) {
+        parts.push(`helpText: '${field.helpText.replace(/'/g, "\\'")}'`);
+    }
+    // Handle field-type specific options
+    if (field.type === 'text' && field.options) {
+        if (field.options.maxLength) {
+            parts.push(`maxLength: ${field.options.maxLength}`);
+        }
+        if (field.options.minLength) {
+            parts.push(`minLength: ${field.options.minLength}`);
+        }
+    }
+    if (field.type === 'number' && field.options) {
+        if (field.options.min !== undefined) {
+            parts.push(`min: ${field.options.min}`);
+        }
+        if (field.options.max !== undefined) {
+            parts.push(`max: ${field.options.max}`);
+        }
+        if (field.options.step !== undefined) {
+            parts.push(`step: ${field.options.step}`);
+        }
+    }
+    if ((field.type === 'select' || field.type === 'multiselect') && field.options?.options) {
+        const options = field.options.options;
+        const optionsStr = options
+            .map((o) => `{ label: '${o.label.replace(/'/g, "\\'")}', value: '${o.value.replace(/'/g, "\\'")}' }`)
+            .join(', ');
+        parts.push(`options: [${optionsStr}]`);
+    }
+    if (field.type === 'entity-reference' && field.options?.referenceTypes) {
+        const refTypes = field.options.referenceTypes;
+        parts.push(`referenceTypes: [${refTypes.map((t) => `'${t}'`).join(', ')}]`);
+        if (field.options.multiple) {
+            parts.push('multiple: true');
+        }
+    }
+    if ((field.type === 'list' || field.type === 'tree') && field.options?.itemType) {
+        parts.push(`itemType: '${field.options.itemType}'`);
+        if (field.options.minItems !== undefined) {
+            parts.push(`minItems: ${field.options.minItems}`);
+        }
+        if (field.options.maxItems !== undefined) {
+            parts.push(`maxItems: ${field.options.maxItems}`);
+        }
+    }
+    if ((field.type === 'image' || field.type === 'video' || field.type === 'file') && field.options) {
+        if (field.options.allowedTypes) {
+            const types = field.options.allowedTypes;
+            parts.push(`allowedTypes: [${types.map((t) => `'${t}'`).join(', ')}]`);
+        }
+        if (field.options.maxSize) {
+            parts.push(`maxSize: ${field.options.maxSize}`);
+        }
+    }
+    return `{ ${parts.join(', ')} }`;
+}

package/dist/writer/write-files.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Write a file to disk with optional Prettier formatting
+ */
+export declare function writeGeneratedFile(filePath: string, content: string, usePrettier?: boolean): Promise<void>;
+/**
+ * Write multiple files in batch
+ */
+export declare function writeFiles(files: Array<{
+    path: string;
+    content: string;
+}>, usePrettier?: boolean): Promise<void>;
+//# sourceMappingURL=write-files.d.ts.map

package/dist/writer/write-files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-files.d.ts","sourceRoot":"","sources":["../../src/writer/write-files.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,WAAW,GAAE,OAAc,GAC1B,OAAO,CAAC,IAAI,CAAC,CAyBf;AAED;;GAEG;AACH,wBAAsB,UAAU,CAC9B,KAAK,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,EAC/C,WAAW,GAAE,OAAc,GAC1B,OAAO,CAAC,IAAI,CAAC,CAMf"}

package/dist/writer/write-files.js

@@ -0,0 +1,35 @@
+import { mkdir, writeFile } from 'fs/promises';
+import { dirname } from 'path';
+import { format } from 'prettier';
+/**
+ * Write a file to disk with optional Prettier formatting
+ */
+export async function writeGeneratedFile(filePath, content, usePrettier = true) {
+    // Ensure directory exists
+    await mkdir(dirname(filePath), { recursive: true });
+    // Format with Prettier if enabled
+    let formattedContent = content;
+    if (usePrettier) {
+        try {
+            const parser = filePath.endsWith('.graphql') ? 'graphql' : 'typescript';
+            formattedContent = await format(content, {
+                parser,
+                semi: true,
+                singleQuote: true,
+                trailingComma: 'es5',
+                printWidth: 100,
+            });
+        }
+        catch (_error) {
+            console.warn(`Warning: Failed to format ${filePath}, writing unformatted`);
+        }
+    }
+    // Write file
+    await writeFile(filePath, formattedContent, 'utf-8');
+}
+/**
+ * Write multiple files in batch
+ */
+export async function writeFiles(files, usePrettier = true) {
+    await Promise.all(files.map((file) => writeGeneratedFile(file.path, file.content, usePrettier)));
+}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@eide/uniformgen",
+  "version": "0.1.0",
+  "description": "Type-safe code generator for Foir - generates TypeScript types and GraphQL operations from your project schemas",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "uniformgen": "./dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.js",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "echo 'UniformGen is a CLI tool. Use ./test-uniformgen.sh to test it locally.'",
+    "dev:cli": "tsx src/cli.ts",
+    "dev:watch": "tsx watch src/cli.ts",
+    "check-types": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "codegen": "graphql-codegen --config codegen.ts"
+  },
+  "keywords": [
+    "foir",
+    "eide",
+    "cms",
+    "codegen",
+    "typescript",
+    "graphql",
+    "type-safety"
+  ],
+  "author": "EIDE Team",
+  "license": "UNLICENSED",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "dotenv": "^16.4.5",
+    "glob": "^10.3.10",
+    "graphql": "^16.9.0",
+    "graphql-request": "^7.1.2",
+    "inquirer": "^9.2.12",
+    "open": "^10.1.0",
+    "ora": "^8.1.1",
+    "prettier": "^3.4.2",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@foir/config": "workspace:*",
+    "@graphql-codegen/cli": "^5.0.7",
+    "@graphql-codegen/client-preset": "^4.8.3",
+    "@graphql-typed-document-node/core": "^3.2.0",
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^22.5.0",
+    "tsx": "^4.20.0",
+    "typescript": "5.9.2",
+    "vitest": "^3.2.4"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}