@tertium/prisma-codegen 0.1.0

package/scripts/generate-client.ts

@@ -0,0 +1,131 @@
+/**
+ * Frontend code generation script — copy this into your project's scripts/ folder
+ * and fill in the Config section below.
+ *
+ * Run: bun scripts/generate-client.ts --api http://localhost:8080
+ */
+
+// ── Config ────────────────────────────────────────────────────────────────────
+
+/** Where to write generated entity files */
+const ENTITIES_DIR = 'src/entities';
+
+/** Path from entity files back to the entities root (used in cross-entity imports) */
+const ENTITY_IMPORT_BASE = '../../entities';
+
+/** Import path for the GraphQL request function */
+const GRAPHQL_REQUEST_IMPORT = '../../core/graphql/graphql.client';
+
+/** Import path for the types barrel (ApiList, PaginationInput, etc.) */
+const API_TYPES_IMPORT = '../../core/graphql/graphql.types.auto';
+
+/** Import path for the TableSchema type */
+const TABLE_SCHEMA_IMPORT = '../../core/rest/rest.types';
+
+/** Import path for the entity options loader service */
+const OPTIONS_SERVICE_IMPORT = '../../core/graphql/graphql.service';
+
+/** Where to write the GraphQL client barrel */
+const GQL_CLIENT_BARREL_OUT = 'src/core/graphql/graphql.client.auto.ts';
+
+/** Where to write the types barrel */
+const GQL_TYPES_BARREL_OUT = 'src/core/graphql/graphql.types.auto.ts';
+
+/** Where to write the enums file */
+const GQL_ENUMS_OUT = 'src/core/graphql/graphql.enums.auto.ts';
+
+/** Where to write the schemas barrel */
+const SCHEMAS_BARREL_OUT = 'src/core/rest/rest.schemas.auto.ts';
+
+/** Enum import path used inside the types barrel */
+const ENUMS_IMPORT = './graphql.enums.auto';
+
+/** Fields excluded from generated forms */
+const SKIP_FIELDS = ['id', 'createdAt', 'updatedAt'];
+
+/** Fields rendered as textarea in forms */
+const LARGE_TEXT_FIELDS: string[] = [];
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+import { existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import type { EntityMeta, EnumMeta } from '@tertium/prisma-codegen/dmmf';
+import {
+  generateClientTypesContent,
+  generateClientSchemaContent,
+  generateGraphQLClientContent,
+  generateClientBarrelContent,
+  generateTypesBarrelContent,
+  generateSchemasBarrelContent,
+  generateEnumsContent,
+} from '@tertium/prisma-codegen/client';
+
+const apiUrl = (() => {
+  const idx = process.argv.indexOf('--api');
+  if (idx === -1 || !process.argv[idx + 1]) {
+    throw new Error('--api <url> is required');
+  }
+  return process.argv[idx + 1];
+})();
+
+console.log(`\nFetching entity metadata from ${apiUrl}/entities ...\n`);
+
+const data = (await fetch(`${apiUrl}/entities`).then((r) => r.json())) as unknown;
+const entities: EntityMeta[] = Array.isArray(data) ? data : (data as any).entities;
+const enums: EnumMeta[] = Array.isArray(data) ? [] : ((data as any).enums ?? []);
+
+console.log(`Found ${entities.length} entities and ${enums.length} enums\n`);
+
+function write(path: string, content: string): void {
+  mkdirSync(join(path, '..'), { recursive: true });
+  writeFileSync(path, content, 'utf-8');
+}
+
+// Remove entity dirs that no longer exist in the API
+if (existsSync(ENTITIES_DIR)) {
+  const activeKebabs = new Set(entities.map((e) => e.kebab));
+  for (const entry of readdirSync(ENTITIES_DIR, { withFileTypes: true })) {
+    if (entry.isDirectory() && !activeKebabs.has(entry.name)) {
+      rmSync(join(ENTITIES_DIR, entry.name), { recursive: true, force: true });
+      console.log(`  ✗ removed entities/${entry.name}/`);
+    }
+  }
+}
+
+for (const entity of entities) {
+  const dir = join(ENTITIES_DIR, entity.kebab);
+
+  write(join(dir, `${entity.kebab}.types.auto.ts`),
+    generateClientTypesContent(entity, entities, enums, {
+      entityImportBase: ENTITY_IMPORT_BASE,
+      enumsImport: ENUMS_IMPORT,
+    }));
+
+  write(join(dir, `${entity.kebab}.schema.auto.ts`),
+    generateClientSchemaContent(entity, {
+      tableSchemaImport: TABLE_SCHEMA_IMPORT,
+      optionsServiceImport: OPTIONS_SERVICE_IMPORT,
+      skipFields: SKIP_FIELDS,
+      largeTextFields: LARGE_TEXT_FIELDS,
+    }));
+
+  write(join(dir, `${entity.kebab}.client.auto.ts`),
+    generateGraphQLClientContent(entity, {
+      graphqlRequestImport: GRAPHQL_REQUEST_IMPORT,
+      apiTypesImport: API_TYPES_IMPORT,
+    }));
+
+  console.log(`  ✓ entities/${entity.kebab}/`);
+}
+
+write(GQL_CLIENT_BARREL_OUT, generateClientBarrelContent(entities, { entityImportBase: ENTITY_IMPORT_BASE }));
+write(GQL_TYPES_BARREL_OUT, generateTypesBarrelContent(entities, enums, { entityImportBase: ENTITY_IMPORT_BASE, enumsImport: ENUMS_IMPORT }));
+write(SCHEMAS_BARREL_OUT, generateSchemasBarrelContent(entities, { entityImportBase: ENTITY_IMPORT_BASE }));
+write(GQL_ENUMS_OUT, generateEnumsContent(enums));
+
+console.log(`\n  ✓ ${GQL_CLIENT_BARREL_OUT}`);
+console.log(`  ✓ ${GQL_TYPES_BARREL_OUT}`);
+console.log(`  ✓ ${SCHEMAS_BARREL_OUT}`);
+console.log(`  ✓ ${GQL_ENUMS_OUT}`);
+console.log(`\n✅ Done — ${entities.length} entities generated.\n`);

package/scripts/generate-server.ts

@@ -0,0 +1,110 @@
+/**
+ * Backend code generation script — copy this into your project's scripts/ folder
+ * and fill in the Config section below.
+ *
+ * Run: bun scripts/generate-server.ts
+ */
+
+// ── Config ────────────────────────────────────────────────────────────────────
+
+/** Import path to your generated PrismaClient */
+const PRISMA_CLIENT_IMPORT = './generated/prisma/client';
+
+/** Import path to your Prisma singleton (used inside generated handlers) */
+const PRISMA_SINGLETON_PATH = '../db/prisma';
+
+/** Import path to your base GraphQL context interface */
+const GRAPHQL_CONTEXT_PATH = './graphql.context';
+
+/** Where to write entity files */
+const ENTITIES_DIR = 'src/entities';
+
+/** Where to write the combined REST router */
+const REST_ROUTER_OUT = 'src/core/rest.router.auto.ts';
+
+/** Where to write the combined GraphQL resolvers */
+const GRAPHQL_RESOLVERS_OUT = 'src/core/graphql.resolvers.auto.ts';
+
+/** String fields whose names match these patterns become full-text searchable */
+const SEARCHABLE_PATTERNS: RegExp[] = [/name/i, /title/i];
+
+/** Int fields whose names match these patterns are treated as enum-like (filterable with 'equals') */
+const ENUM_INT_PATTERNS: RegExp[] = [];
+
+/** Field names excluded from filterable inference */
+const SKIP_FILTERABLE: string[] = [];
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+import { existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import type { DMMFModel } from '@tertium/prisma-codegen/dmmf';
+import {
+  parsePrismaModels,
+  toKebabCase,
+  inferEntityMetadata,
+  generateEntityTypesContent,
+  generateRestHandlerContent,
+  generateRestRouterContent,
+  generateGraphQLResolversContent,
+} from '@tertium/prisma-codegen/server';
+
+function getDMMFModels(): DMMFModel[] {
+  const { PrismaClient } = require(join(process.cwd(), PRISMA_CLIENT_IMPORT.replace(/^\.\//, '')));
+  const pc = new PrismaClient();
+  const runtime = (pc as any)._runtimeDataModel;
+  return Object.entries(runtime.models as Record<string, { fields: any[]; dbName?: string | null }>)
+    .map(([name, m]) => ({ name, dbName: m.dbName, fields: m.fields }));
+}
+
+const dmmfModels = getDMMFModels();
+const models = parsePrismaModels(dmmfModels);
+const metadata = inferEntityMetadata(dmmfModels, {
+  searchableFieldPatterns: SEARCHABLE_PATTERNS,
+  enumLikeIntPatterns: ENUM_INT_PATTERNS,
+  skipFilterableFields: SKIP_FILTERABLE,
+});
+
+console.log(`\n🔄 Generating server code for ${models.length} models...\n`);
+
+// Remove entity dirs that no longer exist in schema
+if (existsSync(ENTITIES_DIR)) {
+  const activeKebabs = new Set(models.map((m) => toKebabCase(m.name)));
+  for (const entry of readdirSync(ENTITIES_DIR, { withFileTypes: true })) {
+    if (entry.isDirectory() && !activeKebabs.has(entry.name)) {
+      rmSync(join(ENTITIES_DIR, entry.name), { recursive: true, force: true });
+      console.log(`  ✗ removed ${entry.name}/`);
+    }
+  }
+}
+
+for (const model of models) {
+  const kebab = toKebabCase(model.name);
+  const dir = join(ENTITIES_DIR, kebab);
+  mkdirSync(dir, { recursive: true });
+
+  writeFileSync(join(dir, `${kebab}.types.auto.ts`), generateEntityTypesContent(model));
+  writeFileSync(
+    join(dir, `${kebab}.rest.auto.ts`),
+    generateRestHandlerContent(model.name, metadata[model.name] ?? {}, {
+      prismaClientPath: PRISMA_SINGLETON_PATH,
+    }),
+  );
+
+  console.log(`  ✓ entities/${kebab}/`);
+}
+
+mkdirSync(REST_ROUTER_OUT.replace(/\/[^/]+$/, ''), { recursive: true });
+writeFileSync(REST_ROUTER_OUT, generateRestRouterContent(models, {
+  entityImportBase: `../${ENTITIES_DIR.split('/').pop()}`,
+}));
+console.log(`\n  ✓ ${REST_ROUTER_OUT}`);
+
+mkdirSync(GRAPHQL_RESOLVERS_OUT.replace(/\/[^/]+$/, ''), { recursive: true });
+writeFileSync(GRAPHQL_RESOLVERS_OUT, generateGraphQLResolversContent(metadata, dmmfModels, {
+  prismaClientPath: PRISMA_CLIENT_IMPORT,
+  contextTypePath: GRAPHQL_CONTEXT_PATH,
+}));
+console.log(`  ✓ ${GRAPHQL_RESOLVERS_OUT}`);
+
+console.log(`\n✅ Done — ${models.length} entities generated.\n`);

package/server/server.test.ts

@@ -0,0 +1,352 @@
+import { describe, it, expect } from 'bun:test';
+import {
+  generateGraphQLResolversContent,
+  generateRestHandlerContent,
+  generateRestRouterContent,
+  parsePrismaModels,
+} from './server';
+import type { DMMFModel } from '../dmmf/dmmf.types';
+
+// ── Shared fixtures ───────────────────────────────────────────────────────────
+
+const PRISMA_PATH = '../../../generated/prisma/client';
+const CONTEXT_PATH = './api-graphql.types.auto';
+
+const dmmfModels: DMMFModel[] = [
+  {
+    name: 'Author',
+    dbName: null,
+    fields: [
+      { name: 'id', kind: 'scalar', type: 'String', isRequired: true, isList: false, isId: true },
+      { name: 'name', kind: 'scalar', type: 'String', isRequired: true, isList: false, isId: false },
+      { name: 'bio', kind: 'scalar', type: 'String', isRequired: false, isList: false, isId: false },
+      { name: 'categoryId', kind: 'scalar', type: 'String', isRequired: false, isList: false, isId: false },
+      {
+        name: 'Category',
+        kind: 'object',
+        type: 'Category',
+        isRequired: false,
+        isList: false,
+        isId: false,
+        relationName: 'AuthorToCategory',
+        relationFromFields: ['categoryId'],
+        relationToFields: ['id'],
+      },
+    ],
+  },
+  {
+    name: 'Category',
+    dbName: null,
+    fields: [
+      { name: 'id', kind: 'scalar', type: 'String', isRequired: true, isList: false, isId: true },
+      { name: 'name', kind: 'scalar', type: 'String', isRequired: true, isList: false, isId: false },
+      {
+        name: 'Author',
+        kind: 'object',
+        type: 'Author',
+        isRequired: false,
+        isList: true,
+        isId: false,
+        relationName: 'AuthorToCategory',
+        relationFromFields: [],
+        relationToFields: [],
+      },
+    ],
+  },
+];
+
+const graphqlMetadata = {
+  Author: {
+    filterable: { name: 'contains' as const, categoryId: 'equals' as const },
+    searchableFields: ['name'],
+    includeRelations: ['Category'],
+  },
+  Category: {
+    filterable: { name: 'contains' as const },
+    searchableFields: ['name'],
+  },
+};
+
+// ── generateGraphQLResolversContent ──────────────────────────────────────────
+
+describe('generateGraphQLResolversContent', () => {
+  describe('without localization', () => {
+    const output = generateGraphQLResolversContent(graphqlMetadata, dmmfModels, {
+      prismaClientPath: PRISMA_PATH,
+      contextTypePath: CONTEXT_PATH,
+    });
+
+    it('imports PrismaClient', () => {
+      expect(output).toContain(`import { PrismaClient } from '${PRISMA_PATH}'`);
+    });
+
+    it('does not import any localization function', () => {
+      expect(output).not.toContain('localizeEntity');
+    });
+
+    it('resolvers do not have a lang parameter', () => {
+      const authorBlock = output.slice(output.indexOf('author:'), output.indexOf('authorList:'));
+      expect(authorBlock).not.toContain('lang');
+    });
+
+    it('generates Query and Mutation resolvers for each model', () => {
+      expect(output).toContain('author:');
+      expect(output).toContain('authorList:');
+      expect(output).toContain('createAuthor:');
+      expect(output).toContain('updateAuthor:');
+      expect(output).toContain('deleteAuthor:');
+    });
+  });
+
+  describe('with localization', () => {
+    const output = generateGraphQLResolversContent(graphqlMetadata, dmmfModels, {
+      prismaClientPath: PRISMA_PATH,
+      contextTypePath: CONTEXT_PATH,
+      localization: { localizeImport: '../localization/localization.entity' },
+    });
+
+    it('imports the consumer localizeEntity function', () => {
+      expect(output).toContain("import { localizeEntity } from '../localization/localization.entity'");
+    });
+
+    it('calls localizeEntity with 3 args in single resolver', () => {
+      expect(output).toContain("await localizeEntity(data, 'Author', lang)");
+    });
+
+    it('calls localizeEntity with 3 args in list resolver', () => {
+      expect(output).toContain("localizeEntity(item, 'Author', lang)");
+    });
+
+    it('adds lang parameter to single resolver args', () => {
+      expect(output).toContain("{ id, lang }: { id: string; lang?: string }");
+    });
+  });
+
+  describe('custom localizeExport name', () => {
+    const output = generateGraphQLResolversContent(graphqlMetadata, dmmfModels, {
+      prismaClientPath: PRISMA_PATH,
+      contextTypePath: CONTEXT_PATH,
+      localization: { localizeImport: './translate', localizeExport: 'translateEntity' },
+    });
+
+    it('uses the custom export name in import', () => {
+      expect(output).toContain("import { translateEntity } from './translate'");
+    });
+
+    it('calls the custom function by its export name', () => {
+      expect(output).toContain("await translateEntity(data, 'Author', lang)");
+    });
+  });
+
+  describe('FK to relation transform', () => {
+    const output = generateGraphQLResolversContent(graphqlMetadata, dmmfModels, {
+      prismaClientPath: PRISMA_PATH,
+      contextTypePath: CONTEXT_PATH,
+    });
+
+    it('generates a transform function for models with FK fields', () => {
+      expect(output).toContain('function transformAuthorInputToPrisma');
+    });
+
+    it('transform connects FK field to relation', () => {
+      expect(output).toContain("result.Category = { connect: { id: value } }");
+    });
+  });
+
+  describe('custom context type', () => {
+    const output = generateGraphQLResolversContent(graphqlMetadata, dmmfModels, {
+      prismaClientPath: PRISMA_PATH,
+      contextTypePath: CONTEXT_PATH,
+      contextTypeExport: 'MyBaseContext',
+      prismaClientExport: 'MyPrismaClient',
+    });
+
+    it('uses custom PrismaClient export name', () => {
+      expect(output).toContain('import { MyPrismaClient }');
+      expect(output).toContain('prisma: MyPrismaClient;');
+    });
+
+    it('uses custom context type export name', () => {
+      expect(output).toContain('import type { MyBaseContext }');
+      expect(output).toContain('extends MyBaseContext');
+    });
+  });
+});
+
+// ── generateRestHandlerContent ────────────────────────────────────────────────
+
+const REST_PRISMA_PATH = '../../db/prisma.client';
+const handlerMetadata = { filterable: { name: 'contains' as const }, searchableFields: ['name', 'title'] };
+
+describe('generateRestHandlerContent', () => {
+  describe('without localization', () => {
+    const output = generateRestHandlerContent('Author', handlerMetadata, { prismaClientPath: REST_PRISMA_PATH });
+
+    it('imports the Prisma client', () => {
+      expect(output).toContain(`import prisma from '${REST_PRISMA_PATH}'`);
+    });
+
+    it('does not import any localization function', () => {
+      expect(output).not.toContain('localizeEntity');
+    });
+
+    it('list signature has no lang parameter', () => {
+      expect(output).toContain('listAuthors(req: Request): Promise<Response>');
+    });
+
+    it('generates the five CRUD functions', () => {
+      expect(output).toContain('export async function listAuthors(');
+      expect(output).toContain('export async function getAuthor(');
+      expect(output).toContain('export async function createAuthor(');
+      expect(output).toContain('export async function updateAuthor(');
+      expect(output).toContain('export async function deleteAuthor(');
+    });
+  });
+
+  describe('with localization', () => {
+    const output = generateRestHandlerContent('Author', handlerMetadata, {
+      prismaClientPath: REST_PRISMA_PATH,
+      localization: { localizeImport: '../../core/localization/localization.entity' },
+    });
+
+    it('imports only the consumer localizeEntity function', () => {
+      expect(output).toContain("import { localizeEntity } from '../../core/localization/localization.entity'");
+    });
+
+    it('list signature accepts lang as an explicit parameter', () => {
+      expect(output).toContain('listAuthors(req: Request, lang?: string): Promise<Response>');
+    });
+
+    it('calls localizeEntity with 3 args in list', () => {
+      expect(output).toContain("localizeEntity(item, 'Author', lang)");
+    });
+
+    it('calls localizeEntity with 3 args in get', () => {
+      expect(output).toContain("localizeEntity(data, 'Author', lang)");
+    });
+  });
+
+  describe('custom localizeExport name', () => {
+    const output = generateRestHandlerContent('Post', {}, {
+      prismaClientPath: REST_PRISMA_PATH,
+      localization: { localizeImport: './my-localize', localizeExport: 'myLocalizer' },
+    });
+
+    it('uses the custom export name in import', () => {
+      expect(output).toContain("import { myLocalizer } from './my-localize'");
+    });
+
+    it('calls the custom function by its export name', () => {
+      expect(output).toContain("myLocalizer(item, 'Post', lang)");
+    });
+  });
+
+  describe('modelName propagation', () => {
+    it('embeds the correct model name in localize calls', () => {
+      const output = generateRestHandlerContent('UserProfile', {}, {
+        prismaClientPath: REST_PRISMA_PATH,
+        localization: { localizeImport: './localize' },
+      });
+      expect(output).toContain("localizeEntity(item, 'UserProfile', lang)");
+      expect(output).toContain("localizeEntity(data, 'UserProfile', lang)");
+    });
+  });
+});
+
+// ── generateRestRouterContent ─────────────────────────────────────────────────
+
+const routerModels = parsePrismaModels([
+  { name: 'Author', dbName: null, fields: [
+    { name: 'id', kind: 'scalar', type: 'String', isRequired: true, isList: false, isId: true },
+    { name: 'name', kind: 'scalar', type: 'String', isRequired: true, isList: false, isId: false },
+  ]},
+  { name: 'Post', dbName: null, fields: [
+    { name: 'id', kind: 'scalar', type: 'String', isRequired: true, isList: false, isId: true },
+    { name: 'name', kind: 'scalar', type: 'String', isRequired: true, isList: false, isId: false },
+  ]},
+]);
+
+describe('generateRestRouterContent', () => {
+  describe('without localization', () => {
+    const output = generateRestRouterContent(routerModels, { entityImportBase: '../entities' });
+
+    it('does not import a getLang function', () => {
+      expect(output).not.toContain('getLanguageFromRequest');
+    });
+
+    it('calls list handler with only req', () => {
+      expect(output).toContain('listAuthors(req)');
+      expect(output).not.toContain('listAuthors(req, lang)');
+    });
+
+    it('dispatches all models', () => {
+      expect(output).toContain("entity === 'authors'");
+      expect(output).toContain("entity === 'posts'");
+    });
+  });
+
+  describe('with localization', () => {
+    const output = generateRestRouterContent(routerModels, {
+      entityImportBase: '../entities',
+      localization: { getLangImport: '../localization/localization.utils', getLangExport: 'getLanguageFromRequest' },
+    });
+
+    it('imports the getLang function', () => {
+      expect(output).toContain("import { getLanguageFromRequest } from '../localization/localization.utils'");
+    });
+
+    it('extracts lang once before the dispatch block', () => {
+      expect(output).toContain('const lang = getLanguageFromRequest(req)');
+      const count = (output.match(/getLanguageFromRequest\(req\)/g) ?? []).length;
+      expect(count).toBe(1);
+    });
+
+    it('passes lang to list and get handlers', () => {
+      expect(output).toContain('listAuthors(req, lang)');
+      expect(output).toContain('getAuthor(id, lang)');
+    });
+
+    it('does not pass lang to create/update/delete', () => {
+      expect(output).toContain('createAuthor(req)');
+      expect(output).not.toContain('createAuthor(req, lang)');
+    });
+
+    it('lang is declared outside the try block', () => {
+      const langPos = output.indexOf('const lang =');
+      const tryPos = output.indexOf('try {');
+      expect(langPos).toBeGreaterThan(0);
+      expect(langPos).toBeLessThan(tryPos);
+    });
+  });
+
+  describe('custom getLangExport name', () => {
+    const output = generateRestRouterContent(routerModels, {
+      entityImportBase: '../entities',
+      localization: { getLangImport: './lang', getLangExport: 'extractLang' },
+    });
+
+    it('uses the custom export name', () => {
+      expect(output).toContain("import { extractLang } from './lang'");
+      expect(output).toContain('const lang = extractLang(req)');
+    });
+  });
+
+  describe('extra routes and imports', () => {
+    const output = generateRestRouterContent(routerModels, {
+      entityImportBase: '../entities',
+      extraImports: `import { handleAuth } from './auth';`,
+      extraRoutes: `  if (pathname === '/api/auth') return handleAuth(req);`,
+      localization: { getLangImport: './lang' },
+    });
+
+    it('includes extra imports', () => {
+      expect(output).toContain("import { handleAuth } from './auth'");
+    });
+
+    it('includes extra routes before entity dispatch', () => {
+      const extraPos = output.indexOf('/api/auth');
+      const entityPos = output.indexOf("entity === 'authors'");
+      expect(extraPos).toBeLessThan(entityPos);
+    });
+  });
+});