@compilr-dev/factory 0.1.7 → 0.1.8

package/dist/toolkits/next-prisma/prisma.js

@@ -0,0 +1,76 @@
+/**
+ * Next.js + Prisma Toolkit — Prisma Schema Generator
+ *
+ * Generates: prisma/schema.prisma, lib/prisma.ts
+ */
+import { toCamelCase } from '../../model/naming.js';
+import { prismaFieldType, prismaModelName, fkFieldName, belongsToRels, hasManyRels, } from './helpers.js';
+export function generatePrismaFiles(model) {
+    return [generateSchema(model), generatePrismaClient()];
+}
+function generateSchema(model) {
+    const lines = [];
+    lines.push(`generator client {`);
+    lines.push(`  provider = "prisma-client-js"`);
+    lines.push(`}`);
+    lines.push('');
+    lines.push(`datasource db {`);
+    lines.push(`  provider = "sqlite"`);
+    lines.push(`  url      = env("DATABASE_URL")`);
+    lines.push(`}`);
+    for (const entity of model.entities) {
+        lines.push('');
+        lines.push(generatePrismaModel(model, entity));
+    }
+    lines.push('');
+    return { path: 'prisma/schema.prisma', content: lines.join('\n') };
+}
+function generatePrismaModel(model, entity) {
+    const modelName = prismaModelName(entity);
+    const bto = belongsToRels(entity);
+    const hm = hasManyRels(entity);
+    const lines = [];
+    lines.push(`model ${modelName} {`);
+    lines.push(`  id        Int      @id @default(autoincrement())`);
+    // Regular fields
+    for (const field of entity.fields) {
+        const pType = prismaFieldType(field);
+        const optional = field.required ? '' : '?';
+        lines.push(`  ${field.name.padEnd(9)} ${pType}${optional}`);
+    }
+    // BelongsTo relationships — FK field + relation
+    for (const rel of bto) {
+        const fk = fkFieldName(rel);
+        const targetModel = prismaModelName({ name: rel.target });
+        const relField = toCamelCase(rel.target);
+        lines.push(`  ${fk.padEnd(9)} Int`);
+        lines.push(`  ${relField.padEnd(9)} ${targetModel}   @relation(fields: [${fk}], references: [id])`);
+    }
+    // HasMany relationships — reverse relation array
+    for (const rel of hm) {
+        const targetEntity = model.entities.find((e) => e.name === rel.target);
+        if (!targetEntity)
+            continue;
+        const targetModel = prismaModelName(targetEntity);
+        const relField = toCamelCase(targetEntity.pluralName);
+        lines.push(`  ${relField.padEnd(9)} ${targetModel}[]`);
+    }
+    // Timestamps
+    lines.push(`  createdAt DateTime @default(now())`);
+    lines.push(`  updatedAt DateTime @updatedAt`);
+    lines.push(`}`);
+    return lines.join('\n');
+}
+function generatePrismaClient() {
+    return {
+        path: 'lib/prisma.ts',
+        content: `import { PrismaClient } from '@prisma/client';
+
+const globalForPrisma = globalThis as unknown as { prisma: PrismaClient };
+
+export const prisma = globalForPrisma.prisma || new PrismaClient();
+
+if (process.env.NODE_ENV !== 'production') globalForPrisma.prisma = prisma;
+`,
+    };
+}

package/dist/toolkits/next-prisma/seed.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Next.js + Prisma Toolkit — Seed Data Generator
+ *
+ * Generates prisma/seed.ts using Prisma's createMany for bulk inserts.
+ * Entities are ordered by dependency (parents before children).
+ */
+import type { ApplicationModel } from '../../model/types.js';
+import type { FactoryFile } from '../types.js';
+export declare function generateSeedFile(model: ApplicationModel): FactoryFile[];

package/dist/toolkits/next-prisma/seed.js

@@ -0,0 +1,100 @@
+/**
+ * Next.js + Prisma Toolkit — Seed Data Generator
+ *
+ * Generates prisma/seed.ts using Prisma's createMany for bulk inserts.
+ * Entities are ordered by dependency (parents before children).
+ */
+import { toCamelCase } from '../../model/naming.js';
+import { fkFieldName, belongsToRels } from './helpers.js';
+import { generateFieldValue, SEED_COUNT } from '../shared/seed-data.js';
+export function generateSeedFile(model) {
+    const ordered = topologicalSort(model.entities);
+    const seedBlocks = ordered.map((entity) => generateEntitySeed(model, entity)).join('\n\n');
+    return [
+        {
+            path: 'prisma/seed.ts',
+            content: `import { PrismaClient } from '@prisma/client';
+
+const prisma = new PrismaClient();
+
+async function main() {
+${seedBlocks}
+
+  console.log('Seed data created successfully.');
+}
+
+main()
+  .then(() => prisma.$disconnect())
+  .catch((e) => {
+    console.error(e);
+    prisma.$disconnect();
+    process.exit(1);
+  });
+`,
+        },
+    ];
+}
+function generateEntitySeed(model, entity) {
+    const camel = toCamelCase(entity.name);
+    const rels = belongsToRels(entity);
+    const items = [];
+    for (let i = 0; i < SEED_COUNT; i++) {
+        const fields = [];
+        for (const field of entity.fields) {
+            const value = generateFieldValue(field, i, entity.name);
+            // For Prisma, booleans and numbers don't need quotes; strings already have them
+            if (field.type === 'date') {
+                // Prisma expects Date objects for DateTime fields
+                fields.push(`      ${field.name}: new Date(${value}),`);
+            }
+            else {
+                fields.push(`      ${field.name}: ${value},`);
+            }
+        }
+        // FK fields from belongsTo relationships
+        for (const rel of rels) {
+            const fk = fkFieldName(rel);
+            const targetCount = SEED_COUNT;
+            fields.push(`      ${fk}: ${String((i % targetCount) + 1)},`);
+        }
+        items.push(`    {\n${fields.join('\n')}\n    },`);
+    }
+    return `  await prisma.${camel}.createMany({
+    data: [
+${items.join('\n')}
+    ],
+  });`;
+}
+/** Sort entities so that parents come before children (entities with belongsTo go after their targets). */
+function topologicalSort(entities) {
+    const entityMap = new Map(entities.map((e) => [e.name, e]));
+    const sorted = [];
+    const visited = new Set();
+    const visiting = new Set();
+    function visit(entity) {
+        if (visited.has(entity.name))
+            return;
+        if (visiting.has(entity.name)) {
+            // Circular dependency — just add it
+            sorted.push(entity);
+            visited.add(entity.name);
+            return;
+        }
+        visiting.add(entity.name);
+        // Visit dependencies first
+        for (const rel of entity.relationships) {
+            if (rel.type === 'belongsTo') {
+                const target = entityMap.get(rel.target);
+                if (target)
+                    visit(target);
+            }
+        }
+        visiting.delete(entity.name);
+        visited.add(entity.name);
+        sorted.push(entity);
+    }
+    for (const entity of entities) {
+        visit(entity);
+    }
+    return sorted;
+}

package/dist/toolkits/next-prisma/static.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Next.js + Prisma Toolkit — Static Files Generator
+ *
+ * Generates: .gitignore, README.md
+ */
+import type { ApplicationModel } from '../../model/types.js';
+import type { FactoryFile } from '../types.js';
+export declare function generateStaticFiles(model: ApplicationModel): FactoryFile[];

package/dist/toolkits/next-prisma/static.js

@@ -0,0 +1,61 @@
+/**
+ * Next.js + Prisma Toolkit — Static Files Generator
+ *
+ * Generates: .gitignore, README.md
+ */
+export function generateStaticFiles(model) {
+    return [generateGitignore(), generateReadme(model)];
+}
+function generateGitignore() {
+    return {
+        path: '.gitignore',
+        content: `node_modules
+.next
+.env
+prisma/dev.db
+prisma/dev.db-journal
+*.local
+`,
+    };
+}
+function generateReadme(model) {
+    let entitiesSection = '';
+    if (model.entities.length > 0) {
+        const entityLines = model.entities
+            .map((e) => {
+            const relCount = e.relationships.length;
+            const parts = [`${String(e.fields.length)} fields`];
+            if (relCount > 0) {
+                parts.push(`${String(relCount)} relationship${relCount > 1 ? 's' : ''}`);
+            }
+            return `- **${e.name}** (${e.icon}) — ${parts.join(', ')}`;
+        })
+            .join('\n');
+        entitiesSection = `\n## Entities\n\n${entityLines}\n`;
+    }
+    return {
+        path: 'README.md',
+        content: `# ${model.identity.name}
+
+${model.identity.description}
+${entitiesSection}
+## Getting Started
+
+\`\`\`bash
+npm install
+npx prisma db push
+npx prisma db seed
+npm run dev
+\`\`\`
+
+- **App:** http://localhost:3000
+
+## Tech Stack
+
+- Next.js 14 (App Router)
+- TypeScript
+- Prisma ORM (SQLite)
+- Tailwind CSS
+`,
+    };
+}

package/dist/toolkits/next-prisma/types-gen.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Next.js + Prisma Toolkit — TypeScript Types Generator
+ *
+ * Generates src/types/index.ts with interfaces for each entity.
+ * These serve as the frontend contract (Client Components use these types;
+ * Prisma generates its own types server-side).
+ */
+import type { ApplicationModel } from '../../model/types.js';
+import type { FactoryFile } from '../types.js';
+export declare function generateTypesFile(model: ApplicationModel): FactoryFile[];

package/dist/toolkits/next-prisma/types-gen.js

@@ -0,0 +1,62 @@
+/**
+ * Next.js + Prisma Toolkit — TypeScript Types Generator
+ *
+ * Generates src/types/index.ts with interfaces for each entity.
+ * These serve as the frontend contract (Client Components use these types;
+ * Prisma generates its own types server-side).
+ */
+import { tsType, fkFieldName, belongsToRels } from './helpers.js';
+const SHARED_TYPES = `// --- Shared API Types ---
+
+export interface PaginatedResponse<T> {
+  data: T[];
+  total: number;
+  page: number;
+  pageSize: number;
+  totalPages: number;
+}
+
+export interface ApiResponse<T> {
+  data: T;
+  error?: string;
+}
+
+export interface ApiListResponse<T> {
+  data: T[];
+  total: number;
+}
+
+export interface SortParams {
+  field: string;
+  direction: 'asc' | 'desc';
+}`;
+export function generateTypesFile(model) {
+    const lines = ['// Auto-generated TypeScript types from Application Model', ''];
+    lines.push(SHARED_TYPES);
+    lines.push('');
+    for (const entity of model.entities) {
+        lines.push(generateInterface(entity));
+        lines.push('');
+    }
+    return [{ path: 'src/types/index.ts', content: lines.join('\n') }];
+}
+function generateInterface(entity) {
+    const lines = [];
+    lines.push(`export interface ${entity.name} {`);
+    lines.push('  id: number;');
+    for (const field of entity.fields) {
+        const optional = field.required ? '' : '?';
+        lines.push(`  ${field.name}${optional}: ${tsType(field)};`);
+    }
+    // FK fields from belongsTo
+    for (const rel of belongsToRels(entity)) {
+        const fk = fkFieldName(rel);
+        lines.push(`  ${fk}: number;`);
+        lines.push(`  ${rel.target.charAt(0).toLowerCase() + rel.target.slice(1)}?: ${rel.target};`);
+    }
+    // Implicit timestamps
+    lines.push('  createdAt: string;');
+    lines.push('  updatedAt: string;');
+    lines.push('}');
+    return lines.join('\n');
+}

package/dist/toolkits/react-node/config.d.ts

@@ -7,7 +7,4 @@
 import type { ApplicationModel } from '../../model/types.js';
 import type { FactoryFile } from '../types.js';
 export declare function generateConfigFiles(model: ApplicationModel): FactoryFile[];
-declare function hexToHsl(hex: string): [number, number, number];
-declare function hslToHex(h: number, s: number, l: number): string;
-declare function generateColorShades(hex: string): string;
-export { hexToHsl, hslToHex, generateColorShades };
+export { hexToHsl, hslToHex, generateColorShades } from '../shared/color-utils.js';

package/dist/toolkits/react-node/config.js

@@ -5,6 +5,7 @@
  * tsconfig.json, postcss.config.js
  */
 import { toKebabCase } from '../../model/naming.js';
+import { generateColorShades } from '../shared/color-utils.js';
 export function generateConfigFiles(model) {
     const appSlug = toKebabCase(model.identity.name);
     return [
@@ -109,90 +110,8 @@ function generateTsConfig() {
     };
     return { path: 'tsconfig.json', content: JSON.stringify(config, null, 2) + '\n' };
 }
-// =============================================================================
-// Color Shade Utilities
-// =============================================================================
-const SHADE_LIGHTNESS = {
-    '50': 97,
-    '100': 94,
-    '200': 86,
-    '300': 77,
-    '400': 66,
-    '500': 55,
-    '600': 44,
-    '700': 36,
-    '800': 27,
-    '900': 20,
-    '950': 14,
-};
-function hexToHsl(hex) {
-    const raw = hex.replace('#', '');
-    const r = parseInt(raw.substring(0, 2), 16) / 255;
-    const g = parseInt(raw.substring(2, 4), 16) / 255;
-    const b = parseInt(raw.substring(4, 6), 16) / 255;
-    const max = Math.max(r, g, b);
-    const min = Math.min(r, g, b);
-    const l = (max + min) / 2;
-    if (max === min)
-        return [0, 0, Math.round(l * 100)];
-    const d = max - min;
-    const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
-    let h = 0;
-    if (max === r)
-        h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
-    else if (max === g)
-        h = ((b - r) / d + 2) / 6;
-    else
-        h = ((r - g) / d + 4) / 6;
-    return [Math.round(h * 360), Math.round(s * 100), Math.round(l * 100)];
-}
-function hslToHex(h, s, l) {
-    const sN = s / 100;
-    const lN = l / 100;
-    const c = (1 - Math.abs(2 * lN - 1)) * sN;
-    const x = c * (1 - Math.abs(((h / 60) % 2) - 1));
-    const m = lN - c / 2;
-    let r = 0, g = 0, b = 0;
-    if (h < 60)
-        [r, g, b] = [c, x, 0];
-    else if (h < 120)
-        [r, g, b] = [x, c, 0];
-    else if (h < 180)
-        [r, g, b] = [0, c, x];
-    else if (h < 240)
-        [r, g, b] = [0, x, c];
-    else if (h < 300)
-        [r, g, b] = [x, 0, c];
-    else
-        [r, g, b] = [c, 0, x];
-    const toHex = (v) => Math.round((v + m) * 255)
-        .toString(16)
-        .padStart(2, '0');
-    return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
-}
-function generateColorShades(hex) {
-    const [h, s] = hexToHsl(hex);
-    const entries = [];
-    for (const [shade, lightness] of Object.entries(SHADE_LIGHTNESS)) {
-        entries.push(`          ${shade}: '${hslToHex(h, s, lightness)}',`);
-    }
-    // Find the shade closest to the original for DEFAULT
-    const [, , originalL] = hexToHsl(hex);
-    let closestShade = '500';
-    let closestDiff = Infinity;
-    for (const [shade, lightness] of Object.entries(SHADE_LIGHTNESS)) {
-        const diff = Math.abs(lightness - originalL);
-        if (diff < closestDiff) {
-            closestDiff = diff;
-            closestShade = shade;
-        }
-    }
-    const defaultHex = hslToHex(h, s, SHADE_LIGHTNESS[closestShade]);
-    entries.push(`          DEFAULT: '${defaultHex}',`);
-    return `{\n${entries.join('\n')}\n        }`;
-}
-// Export for testing
-export { hexToHsl, hslToHex, generateColorShades };
+// Re-export for testing (from shared)
+export { hexToHsl, hslToHex, generateColorShades } from '../shared/color-utils.js';
 function generatePostCssConfig() {
     return {
         path: 'postcss.config.js',

package/dist/toolkits/react-node/helpers.d.ts

@@ -1,27 +1,6 @@
 /**
  * React+Node Toolkit — Shared Helpers
  *
- * Utility functions used across generators.
+ * Re-exports from the shared helpers module.
  */
-import type { Entity, Field, Relationship } from '../../model/types.js';
-/** Indent every line of a multi-line string. */
-export declare function indent(text: string, spaces: number): string;
-/** Map a model FieldType to a TypeScript type string. */
-export declare function tsType(field: Field): string;
-/** Get the FK field name for a belongsTo relationship. */
-export declare function fkFieldName(rel: Relationship): string;
-/** Get belongsTo relationships for an entity. */
-export declare function belongsToRels(entity: Entity): readonly Relationship[];
-/** Get hasMany relationships for an entity. */
-export declare function hasManyRels(entity: Entity): readonly Relationship[];
-/** Generate a route path from entity plural name. */
-export declare function routePath(entity: Entity): string;
-/** Generate an API path from entity plural name. */
-export declare function apiPath(entity: Entity): string;
-/** Map a model FieldType to an HTML input type. */
-export declare function inputType(field: Field): string;
-/** Generate import statement lines. */
-export declare function generateImports(imports: Array<{
-    from: string;
-    names: string[];
-}>): string;
+export { indent, tsType, fkFieldName, belongsToRels, hasManyRels, routePath, apiPath, inputType, generateImports, } from '../shared/helpers.js';

package/dist/toolkits/react-node/helpers.js

@@ -1,71 +1,6 @@
 /**
  * React+Node Toolkit — Shared Helpers
  *
- * Utility functions used across generators.
+ * Re-exports from the shared helpers module.
  */
-import { toCamelCase, toKebabCase } from '../../model/naming.js';
-/** Indent every line of a multi-line string. */
-export function indent(text, spaces) {
-    const pad = ' '.repeat(spaces);
-    return text
-        .split('\n')
-        .map((line) => (line.trim() === '' ? '' : pad + line))
-        .join('\n');
-}
-/** Map a model FieldType to a TypeScript type string. */
-export function tsType(field) {
-    switch (field.type) {
-        case 'string':
-        case 'enum':
-            return 'string';
-        case 'number':
-            return 'number';
-        case 'boolean':
-            return 'boolean';
-        case 'date':
-            return 'string'; // ISO date string
-        default:
-            return 'string';
-    }
-}
-/** Get the FK field name for a belongsTo relationship. */
-export function fkFieldName(rel) {
-    return rel.fieldName ?? toCamelCase(rel.target) + 'Id';
-}
-/** Get belongsTo relationships for an entity. */
-export function belongsToRels(entity) {
-    return entity.relationships.filter((r) => r.type === 'belongsTo');
-}
-/** Get hasMany relationships for an entity. */
-export function hasManyRels(entity) {
-    return entity.relationships.filter((r) => r.type === 'hasMany');
-}
-/** Generate a route path from entity plural name. */
-export function routePath(entity) {
-    return '/' + toKebabCase(entity.pluralName).toLowerCase();
-}
-/** Generate an API path from entity plural name. */
-export function apiPath(entity) {
-    return '/api/' + toKebabCase(entity.pluralName).toLowerCase();
-}
-/** Map a model FieldType to an HTML input type. */
-export function inputType(field) {
-    switch (field.type) {
-        case 'string':
-            return 'text';
-        case 'number':
-            return 'number';
-        case 'boolean':
-            return 'checkbox';
-        case 'date':
-            return 'date';
-        case 'enum':
-            return 'select';
-        default:
-            return 'text';
-    }
-}
-/** Generate import statement lines. */
-export function generateImports(imports) {
-    return imports.map((i) => `import { ${i.names.join(', ')} } from '${i.from}';`).join('\n');
-}
+export { indent, tsType, fkFieldName, belongsToRels, hasManyRels, routePath, apiPath, inputType, generateImports, } from '../shared/helpers.js';

package/dist/toolkits/react-node/seed.d.ts

@@ -2,10 +2,11 @@
  * React+Node Toolkit — Seed Data Generator
  *
  * Generates realistic mock data based on field semantics.
- * Deterministic: same input → same output (uses index-based logic, not Math.random).
+ * Uses shared generateFieldValue for deterministic values,
+ * wraps them in JavaScript array format for in-memory data stores.
  */
 import type { ApplicationModel, Entity } from '../../model/types.js';
-declare const SEED_COUNT = 8;
-/** Generate seed data items for a single entity. */
+import { SEED_COUNT } from '../shared/seed-data.js';
+/** Generate seed data items for a single entity (JS array format). */
 export declare function generateSeedData(model: ApplicationModel, entity: Entity): string;
 export { SEED_COUNT };