@compilr-dev/factory 0.1.6 → 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/api.js

@@ -4,7 +4,7 @@
  * Generates: server/index.ts, server/routes/{entity}.ts, server/data/{entity}.ts
  */
 import { toCamelCase, toKebabCase } from '../../model/naming.js';
-import { tsType, fkFieldName, belongsToRels } from './helpers.js';
+import { tsType, fkFieldName, belongsToRels, hasManyRels } from './helpers.js';
 import { generateSeedData } from './seed.js';
 export function generateApiFiles(model) {
     return [
@@ -71,6 +71,23 @@ function generateDataStore(model, entity) {
     }
     typeFields.push('  createdAt: string;');
     typeFields.push('  updatedAt: string;');
+    // Collect searchable fields (string + enum types)
+    const searchableFields = entity.fields
+        .filter((f) => f.type === 'string' || f.type === 'enum')
+        .map((f) => `item.${f.name}`);
+    const searchFilter = searchableFields.length > 0
+        ? `    const q = options.search.toLowerCase();
+    result = result.filter((item) =>
+      [${searchableFields.join(', ')}].some((v) =>
+        v !== undefined && String(v).toLowerCase().includes(q),
+      ),
+    );`
+        : `    const q = options.search.toLowerCase();
+    result = result.filter((item) =>
+      Object.values(item).some((v) =>
+        v !== undefined && String(v).toLowerCase().includes(q),
+      ),
+    );`;
     const seedData = generateSeedData(model, entity);
     return {
         path: `server/data/${fileName}.ts`,
@@ -80,6 +97,11 @@ export interface ${typeName}Record {
 ${typeFields.join('\n')}
 }
 
+export interface QueryOptions {
+  search?: string;
+  filters?: Record<string, string>;
+}
+
 ${seedData}
 
 let items: ${typeName}Record[] = [...${varName}SeedData];
@@ -93,6 +115,21 @@ export function getById(id: number): ${typeName}Record | undefined {
   return items.find((item) => item.id === id);
 }
 
+export function query(options: QueryOptions): { data: ${typeName}Record[]; total: number } {
+  let result = items;
+  if (options.search) {
+${searchFilter}
+  }
+  if (options.filters) {
+    for (const [field, value] of Object.entries(options.filters)) {
+      result = result.filter((item) =>
+        String((item as Record<string, unknown>)[field]) === value,
+      );
+    }
+  }
+  return { data: result, total: result.length };
+}
+
 export function create(data: Omit<${typeName}Record, 'id' | 'createdAt' | 'updatedAt'>): ${typeName}Record {
   const now = new Date().toISOString();
   const item = { ...data, id: nextId++, createdAt: now, updatedAt: now };
@@ -124,6 +161,7 @@ function generateRoutes(model, entity) {
     const varName = toCamelCase(entity.pluralName) + 'Router';
     const dataImport = fileName;
     const btoRels = belongsToRels(entity);
+    const hmRels = hasManyRels(entity);
     // Populate belongsTo entities
     const populateImports = btoRels
         .map((rel) => {
@@ -135,6 +173,17 @@ function generateRoutes(model, entity) {
     })
         .filter(Boolean)
         .join('\n');
+    // Aliased getAll imports for hasMany targets (used by ?include=)
+    const hasManyImports = hmRels
+        .map((rel) => {
+        const targetEntity = model.entities.find((e) => e.name === rel.target);
+        if (!targetEntity)
+            return '';
+        const targetFile = toKebabCase(targetEntity.pluralName).toLowerCase();
+        return `import { getAll as getAll${targetEntity.pluralName} } from '../data/${targetFile}.js';`;
+    })
+        .filter(Boolean)
+        .join('\n');
     const populateLogic = btoRels.length > 0
         ? `
 function populate(item: Record<string, unknown>): Record<string, unknown> {
@@ -151,30 +200,64 @@ ${btoRels
 `
         : '';
     const getListReturn = btoRels.length > 0
-        ? 'res.json(items.map((item) => populate(item as unknown as Record<string, unknown>)));'
-        : 'res.json(items);';
-    const getByIdReturn = btoRels.length > 0
-        ? 'res.json(populate(item as unknown as Record<string, unknown>));'
-        : 'res.json(item);';
+        ? 'res.json({ data: result.data.map((item) => populate(item as unknown as Record<string, unknown>)), total: result.total });'
+        : 'res.json({ data: result.data, total: result.total });';
+    // GET by ID with optional ?include= for hasMany
+    let getByIdBody;
+    if (hmRels.length > 0) {
+        const includeChecks = hmRels
+            .map((rel) => {
+            const targetEntity = model.entities.find((e) => e.name === rel.target);
+            if (!targetEntity)
+                return '';
+            const targetVar = toCamelCase(targetEntity.pluralName);
+            const fkRel = targetEntity.relationships.find((r) => r.type === 'belongsTo' && r.target === entity.name) ?? { type: 'belongsTo', target: entity.name };
+            const fk = fkFieldName(fkRel);
+            return `  if (include.includes('${targetVar}')) {
+    result.${targetVar} = getAll${targetEntity.pluralName}().filter((r) => r.${fk} === item.id);
+  }`;
+        })
+            .filter(Boolean)
+            .join('\n');
+        const populateExpr = btoRels.length > 0 ? 'populate(item as unknown as Record<string, unknown>)' : '{ ...item }';
+        getByIdBody = `  const item = getById(Number(req.params.id));
+  if (!item) return res.status(404).json({ error: 'Not found' });
+  const include = (req.query.include as string ?? '').split(',').filter(Boolean);
+  const result: Record<string, unknown> = ${populateExpr};
+${includeChecks}
+  res.json(result);`;
+    }
+    else {
+        const getByIdReturn = btoRels.length > 0
+            ? 'res.json(populate(item as unknown as Record<string, unknown>));'
+            : 'res.json(item);';
+        getByIdBody = `  const item = getById(Number(req.params.id));
+  if (!item) return res.status(404).json({ error: 'Not found' });
+  ${getByIdReturn}`;
+    }
     return {
         path: `server/routes/${fileName}.ts`,
         content: `import { Router } from 'express';
-import { getAll, getById, create, update, remove } from '../data/${dataImport}.js';
-${populateImports}
+import { getAll, getById, query, create, update, remove } from '../data/${dataImport}.js';
+${populateImports}${hasManyImports ? '\n' + hasManyImports : ''}
 
 export const ${varName} = Router();
 ${populateLogic}
 // GET all
-${varName}.get('/', (_req, res) => {
-  const items = getAll();
+${varName}.get('/', (req, res) => {
+  const search = req.query.search as string | undefined;
+  const filters: Record<string, string> = {};
+  for (const [key, value] of Object.entries(req.query)) {
+    const match = key.match(/^filter\\[(.+)\\]$/);
+    if (match && typeof value === 'string') filters[match[1]] = value;
+  }
+  const result = query({ search, filters });
   ${getListReturn}
 });
 
 // GET by ID
 ${varName}.get('/:id', (req, res) => {
-  const item = getById(Number(req.params.id));
-  if (!item) return res.status(404).json({ error: 'Not found' });
-  ${getByIdReturn}
+${getByIdBody}
 });
 
 // POST create

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',