@tertium/prisma-codegen 0.1.0

package/client/client.ts

@@ -0,0 +1,328 @@
+import type { EntityMeta, EnumMeta } from '../dmmf/dmmf.types';
+import { toKebabCase as _toKebabCase } from '../dmmf/dmmf.utils';
+import type {
+  ClientTypesConfig,
+  ClientSchemaConfig,
+  GraphQLClientConfig,
+  ClientBarrelConfig,
+  TypesBarrelConfig,
+  SchemasBarrelConfig,
+} from './client.types';
+
+// ── Types generator ───────────────────────────────────────────────────────────
+
+export function generateClientTypesContent(
+  entity: EntityMeta,
+  allEntities: EntityMeta[],
+  enums: EnumMeta[],
+  config: ClientTypesConfig,
+): string {
+  const { entityImportBase, enumsImport } = config;
+
+  const entityNames = new Set(allEntities.map((e) => e.name));
+  const enumNames = new Set(enums.map((e) => e.name));
+
+  const entitiesToImport = new Set<string>();
+  const enumsToImport = new Set<string>();
+
+  for (const f of entity.fields) {
+    if (!f.isRelation || !f.tsType || f.tsType === entity.name) continue;
+    if (entityNames.has(f.tsType)) entitiesToImport.add(f.tsType);
+    else if (enumNames.has(f.tsType)) enumsToImport.add(f.tsType);
+  }
+
+  const entityImports = Array.from(entitiesToImport)
+    .sort()
+    .map((type) => {
+      const kebab = _toKebabCase(type);
+      return `import type { ${type} } from '${entityImportBase}/${kebab}/${kebab}.types.auto';`;
+    })
+    .join('\n');
+
+  const enumImport =
+    enumsToImport.size > 0
+      ? `import { ${Array.from(enumsToImport).sort().join(', ')} } from '${enumsImport}';`
+      : '';
+
+  const importSection = [entityImports, enumImport].filter(Boolean).join('\n');
+
+  const fields = entity.fields
+    .map((f) => {
+      const optional = f.required ? '' : '?';
+      if (f.isRelation && entityNames.has(f.tsType)) {
+        if (f.isArray) return `  ${f.name}${optional}: ${f.tsType}[];`;
+        return `  ${f.name}${optional}: ${f.tsType}${f.required ? '' : ' | null'};`;
+      }
+      let fieldType = f.tsType;
+      if (
+        f.isRelation &&
+        !entityNames.has(f.tsType) &&
+        !enumNames.has(f.tsType) &&
+        /^[A-Z]/.test(f.tsType) &&
+        !f.tsType.includes('|')
+      ) {
+        fieldType = 'string';
+      }
+      return `  ${f.name}${optional}: ${fieldType};`;
+    })
+    .join('\n');
+
+  return `/**
+ * ${entity.displayName} — auto-generated, do not edit
+ */
+
+${importSection ? importSection + '\n\n' : ''}export interface ${entity.name} {
+${fields}
+}
+`;
+}
+
+// ── Schema generator ──────────────────────────────────────────────────────────
+
+function _prettifyLabel(name: string): string {
+  const words = name.replace(/([A-Z])/g, ' $1').trim().split(' ');
+  return words
+    .map((w, i) => {
+      const t = w.slice(0, 16);
+      return i === 0 ? t : t.charAt(0).toUpperCase() + t.slice(1);
+    })
+    .join('');
+}
+
+export function generateClientSchemaContent(entity: EntityMeta, config: ClientSchemaConfig): string {
+  const {
+    tableSchemaImport,
+    optionsServiceImport,
+    optionsServiceExport = 'fetchAllEntityOptions',
+    skipFields = [],
+    largeTextFields = [],
+  } = config;
+
+  const skipSet = new Set(skipFields);
+  const largeTextSet = new Set(largeTextFields);
+
+  const formFields = entity.fields.filter((f) => !f.isRelation && !skipSet.has(f.name));
+  const regularFields = formFields.filter((f) => !largeTextSet.has(f.name));
+  const textareaFields = formFields.filter((f) => largeTextSet.has(f.name));
+
+  const regularDefs = regularFields
+    .map((f) => {
+      const label = _prettifyLabel(f.name);
+      const required = f.required ? ', required: true' : '';
+
+      if (f.formType === 'relation' && f.relationModel) {
+        return `  {
+    name: '${f.name}',
+    label: '${label}',
+    type: 'relation' as const,
+    optionsLoader: async () => {
+      const { ${optionsServiceExport} } = await import('${optionsServiceImport}');
+      return ${optionsServiceExport}('${f.relationModel}');
+    },
+  }`;
+      }
+
+      return `  { name: '${f.name}', label: '${label}', type: '${f.formType}'${required} }`;
+    })
+    .join(',\n');
+
+  const textareaDefs = textareaFields
+    .map((f) => `  { name: '${f.name}', label: '${_prettifyLabel(f.name)}', type: 'textarea' }`)
+    .join(',\n');
+
+  const allDefs = [regularDefs, textareaDefs].filter(Boolean).join(',\n');
+
+  return `/**
+ * ${entity.displayName} Schema — auto-generated, do not edit
+ */
+
+import type { TableSchema } from '${tableSchemaImport}';
+
+export const ${entity.camel}Schema: TableSchema = {
+  name: '${entity.kebab}',
+  displayName: '${entity.displayName}',
+  primaryKey: 'id',
+  sortField: 'name',
+  fields: [
+${allDefs},
+  ],
+};
+`;
+}
+
+// ── GraphQL client generator ──────────────────────────────────────────────────
+
+export function generateGraphQLClientContent(entity: EntityMeta, config: GraphQLClientConfig): string {
+  const { graphqlRequestImport, graphqlRequestExport = 'graphqlRequest', apiTypesImport } = config;
+
+  const allFields = entity.fields
+    .map((f) => {
+      if (f.isRelation) return `        ${f.name} {\n          id\n          title\n        }`;
+      return `        ${f.name}`;
+    })
+    .join('\n');
+
+  return `/**
+ * ${entity.displayName} Client — auto-generated, do not edit
+ */
+
+import { ${graphqlRequestExport} } from '${graphqlRequestImport}';
+import type { ApiList, PaginationInput } from '${apiTypesImport}';
+import type { ${entity.name} } from './${entity.kebab}.types.auto';
+
+export async function fetch${entity.name}(id: string): Promise<${entity.name} | null> {
+  const data = await ${graphqlRequestExport}<{ ${entity.camel}: ${entity.name} | null }>(\`
+    query Get${entity.name}($id: String!) {
+      ${entity.camel}(id: $id) {
+${allFields}
+      }
+    }
+  \`, { id });
+  return data.${entity.camel};
+}
+
+export async function fetch${entity.name}List(filter?: any, pagination?: PaginationInput): Promise<ApiList<${entity.name}>> {
+  const data = await ${graphqlRequestExport}<{ ${entity.camel}List: ApiList<${entity.name}> }>(\`
+    query Get${entity.name}List($filter: JSON, $pagination: PaginationInput) {
+      ${entity.camel}List(filter: $filter, pagination: $pagination) {
+        data {
+${allFields}
+        }
+        total
+      }
+    }
+  \`, { filter, pagination });
+  return data.${entity.camel}List;
+}
+
+export async function create${entity.name}(input: Partial<${entity.name}>): Promise<${entity.name}> {
+  const data = await ${graphqlRequestExport}<{ create${entity.name}: ${entity.name} }>(\`
+    mutation Create${entity.name}($input: Create${entity.name}Input!) {
+      create${entity.name}(input: $input) { id }
+    }
+  \`, { input });
+  return data.create${entity.name};
+}
+
+export async function update${entity.name}(id: string, input: Partial<${entity.name}>): Promise<${entity.name}> {
+  const data = await ${graphqlRequestExport}<{ update${entity.name}: ${entity.name} }>(\`
+    mutation Update${entity.name}($id: String!, $input: Update${entity.name}Input!) {
+      update${entity.name}(id: $id, input: $input) { id }
+    }
+  \`, { id, input });
+  return data.update${entity.name};
+}
+
+export async function delete${entity.name}(id: string): Promise<boolean> {
+  const data = await ${graphqlRequestExport}<{ delete${entity.name}: boolean }>(\`
+    mutation Delete${entity.name}($id: String!) {
+      delete${entity.name}(id: $id)
+    }
+  \`, { id });
+  return data.delete${entity.name};
+}
+`;
+}
+
+// ── Barrel generators ─────────────────────────────────────────────────────────
+
+export function generateClientBarrelContent(entities: EntityMeta[], config: ClientBarrelConfig): string {
+  const exports = entities
+    .map((e) => `export * from '${config.entityImportBase}/${e.kebab}/${e.kebab}.client.auto';`)
+    .join('\n');
+
+  return `/**
+ * GraphQL Client — auto-generated barrel, do not edit
+ */
+
+${exports}
+`;
+}
+
+export function generateTypesBarrelContent(
+  entities: EntityMeta[],
+  enums: EnumMeta[],
+  config: TypesBarrelConfig,
+): string {
+  const { entityImportBase, enumsImport } = config;
+
+  const typeExports = entities
+    .map((e) => `export type { ${e.name} } from '${entityImportBase}/${e.kebab}/${e.kebab}.types.auto';`)
+    .join('\n');
+
+  const enumsLine = enumsImport && enums.length > 0 ? `\nexport * from '${enumsImport}';\n` : '';
+
+  return `/**
+ * API Types — auto-generated barrel, do not edit
+ */
+
+export interface ApiList<T> {
+  data: T[];
+  total: number;
+}
+
+export interface PaginationInput {
+  limit?: number;
+  offset?: number;
+}
+
+export interface SortInput {
+  field: string;
+  direction: 'ASC' | 'DESC';
+}
+
+export interface EntityOption {
+  value: string;
+  label: string;
+}
+
+export interface EntityOptionsPage {
+  options: EntityOption[];
+  total: number;
+  hasMore: boolean;
+}
+
+export interface EntityItem {
+  id: string;
+  title?: string;
+  name?: string;
+}
+
+${typeExports}${enumsLine}
+`;
+}
+
+export function generateSchemasBarrelContent(entities: EntityMeta[], config: SchemasBarrelConfig): string {
+  const exports = entities
+    .map((e) => `export { ${e.camel}Schema } from '${config.entityImportBase}/${e.kebab}/${e.kebab}.schema.auto';`)
+    .join('\n');
+
+  return `/**
+ * Table Schemas — auto-generated barrel, do not edit
+ */
+
+${exports}
+`;
+}
+
+export function generateEnumsContent(enums: EnumMeta[]): string {
+  if (enums.length === 0) {
+    return `/**
+ * API Enums — auto-generated, do not edit
+ */
+
+// No enums defined
+`;
+  }
+
+  const enumDefs = enums
+    .map((e) => `export enum ${e.name} {\n${e.values.map((v) => `  ${v} = '${v}',`).join('\n')}\n}`)
+    .join('\n\n');
+
+  return `/**
+ * API Enums — auto-generated from Prisma schema, do not edit
+ */
+
+${enumDefs}
+`;
+}

package/client/client.types.ts

@@ -0,0 +1,33 @@
+// ── Config types ──────────────────────────────────────────────────────────────
+
+export interface ClientTypesConfig {
+  entityImportBase: string;
+  enumsImport: string;
+}
+
+export interface ClientSchemaConfig {
+  tableSchemaImport: string;
+  optionsServiceImport: string;
+  optionsServiceExport?: string;
+  skipFields?: string[];
+  largeTextFields?: string[];
+}
+
+export interface GraphQLClientConfig {
+  graphqlRequestImport: string;
+  graphqlRequestExport?: string;
+  apiTypesImport: string;
+}
+
+export interface ClientBarrelConfig {
+  entityImportBase: string;
+}
+
+export interface TypesBarrelConfig {
+  entityImportBase: string;
+  enumsImport?: string;
+}
+
+export interface SchemasBarrelConfig {
+  entityImportBase: string;
+}

package/dmmf/dmmf.types.ts

@@ -0,0 +1,53 @@
+// ── DMMF input types (compatible with PrismaClient._runtimeDataModel) ────────
+
+export type FilterMode = 'contains' | 'equals';
+
+export type DMMFField = {
+  name: string;
+  kind: 'scalar' | 'object' | 'enum' | 'unsupported';
+  type: string;
+  isRequired: boolean;
+  isList: boolean;
+  isId: boolean;
+  relationName?: string;
+  relationFromFields?: readonly string[];
+  relationToFields?: readonly string[];
+};
+
+export type DMMFModel = {
+  name: string;
+  dbName?: string | null;
+  fields: readonly DMMFField[];
+};
+
+export type DMMFEnum = {
+  name: string;
+  values: readonly { name: string }[];
+};
+
+// ── EntityMeta types (served by /entities, consumed by frontend generator) ───
+
+export interface FieldMeta {
+  name: string;
+  prismaType: string;
+  tsType: string;
+  formType: string;
+  required: boolean;
+  isPrimary: boolean;
+  isRelation: boolean;
+  isArray: boolean;
+  relationModel: string | null;
+}
+
+export interface EntityMeta {
+  name: string;
+  camel: string;
+  kebab: string;
+  displayName: string;
+  fields: FieldMeta[];
+}
+
+export interface EnumMeta {
+  name: string;
+  values: string[];
+}

package/dmmf/dmmf.utils.ts

@@ -0,0 +1,125 @@
+import type { DMMFField, DMMFModel, DMMFEnum, FieldMeta, EntityMeta, EnumMeta } from './dmmf.types';
+
+// ── Type mappings ─────────────────────────────────────────────────────────────
+
+const PRISMA_TO_TS: Record<string, string> = {
+  String: 'string',
+  Int: 'number',
+  Float: 'number',
+  Boolean: 'boolean',
+  DateTime: 'string',
+  BigInt: 'number',
+  Decimal: 'number',
+  Json: 'any',
+  Bytes: 'string',
+};
+
+const PRISMA_TO_FORM: Record<string, string> = {
+  Int: 'number',
+  BigInt: 'number',
+  Float: 'float',
+  Decimal: 'float',
+  Boolean: 'boolean',
+  DateTime: 'date',
+  Json: 'textarea',
+};
+
+// ── String utilities ───────────────────────────────────────────────────────────
+
+export function toCamelCase(str: string): string {
+  return str.charAt(0).toLowerCase() + str.slice(1);
+}
+
+export function toKebabCase(str: string): string {
+  return str.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();
+}
+
+export function toDisplayName(str: string): string {
+  return str.replace(/([A-Z])/g, ' $1').trim();
+}
+
+// ── Field type utilities ───────────────────────────────────────────────────────
+
+export function scalarTsType(prismaType: string, required: boolean): string {
+  const base = PRISMA_TO_TS[prismaType] ?? 'string';
+  return required ? base : `${base} | null`;
+}
+
+export function scalarFormType(prismaType: string, fieldName: string): string {
+  if (fieldName.endsWith('Id')) return 'relation';
+  return PRISMA_TO_FORM[prismaType] ?? 'text';
+}
+
+// ── Field mapping ──────────────────────────────────────────────────────────────
+
+export function buildFkRelationMap(model: DMMFModel): Map<string, string> {
+  const map = new Map<string, string>();
+  for (const field of model.fields) {
+    if (field.kind === 'object' && field.relationFromFields?.length) {
+      for (const fkName of field.relationFromFields) {
+        map.set(fkName, field.type);
+      }
+    }
+  }
+  return map;
+}
+
+export function mapField(f: DMMFField, fkRelationMap: Map<string, string>): FieldMeta {
+  if (f.kind === 'object') {
+    return {
+      name: f.name,
+      prismaType: f.type,
+      tsType: f.type,
+      formType: 'relation',
+      required: f.isRequired,
+      isPrimary: false,
+      isRelation: true,
+      isArray: f.isList,
+      relationModel: f.type,
+    };
+  }
+
+  const tsType =
+    f.kind === 'enum'
+      ? f.isRequired
+        ? f.type
+        : `${f.type} | null`
+      : scalarTsType(f.type, f.isRequired);
+
+  return {
+    name: f.name,
+    prismaType: f.type,
+    tsType,
+    formType: f.kind === 'enum' ? 'text' : scalarFormType(f.type, f.name),
+    required: f.isRequired,
+    isPrimary: f.isId,
+    isRelation: false,
+    isArray: f.isList,
+    relationModel: f.name.endsWith('Id') ? (fkRelationMap.get(f.name) ?? null) : null,
+  };
+}
+
+// ── DMMF to EntityMeta conversion ───────────────────────────────────────────────
+
+export function dmmfToEntityMeta(
+  dmmfModels: readonly DMMFModel[],
+  dmmfEnums: readonly DMMFEnum[],
+): { entities: EntityMeta[]; enums: EnumMeta[] } {
+  const entities: EntityMeta[] = dmmfModels.map((model) => {
+    const fkRelationMap = buildFkRelationMap(model);
+    return {
+      name: model.name,
+      camel: toCamelCase(model.name),
+      kebab: toKebabCase(model.name),
+      displayName: toDisplayName(model.name),
+      fields: model.fields.map((f) => mapField(f, fkRelationMap)),
+    };
+  });
+
+  const enums: EnumMeta[] = dmmfEnums.map((e) => ({
+    name: e.name,
+    values: e.values.map((v) => v.name),
+  }));
+
+  return { entities, enums };
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@tertium/prisma-codegen",
+  "version": "0.1.0",
+  "description": "Universal Prisma schema code generation — REST handlers, GraphQL resolvers, TypeScript types.",
+  "type": "module",
+  "exports": {
+    "./server": "./server/server.ts",
+    "./client": "./client/client.ts",
+    "./dmmf": "./dmmf/dmmf.types.ts"
+  },
+  "files": [
+    "dmmf/",
+    "server/",
+    "client/",
+    "scripts/",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "bun test",
+    "lint:ts:check": "bunx tsc --noEmit",
+    "release:patch": "node node_modules/@tertium/js/scripts/release.js patch",
+    "release:minor": "node node_modules/@tertium/js/scripts/release.js minor",
+    "release:major": "node node_modules/@tertium/js/scripts/release.js major"
+  },
+  "author": "Vitalii Balabanov",
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@tertium/js": "^1.4.8",
+    "@types/bun": "^1.3.9",
+    "typescript": "^5.8.3"
+  }
+}