gazan-init 0.1.0

package/src/generators/database/prisma.js

@@ -0,0 +1,61 @@
+"use strict";
+
+const { isEsm } = require("../syntax");
+const { generatePrismaSchema } = require("../entity/toPrisma");
+
+function defaultPrismaSchema() {
+  return `generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+
+// Starter model so \`prisma generate\`/\`migrate\` work out of the box.
+// Replace this with your own models, or regenerate with an entity.json.
+model Example {
+  id        String   @id @default(uuid())
+  name      String
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  @@map("examples")
+}
+`;
+}
+
+function generateSchemaPrisma(config, entityModel) {
+  if (entityModel && entityModel.models.length > 0) {
+    return generatePrismaSchema(entityModel, config);
+  }
+  return defaultPrismaSchema();
+}
+
+/** configs/db/index.{js,ts} — centralized PrismaClient lifecycle. No service instantiates its own client. */
+function generatePrismaDbConfig(config) {
+  const esm = isEsm(config);
+  const isTs = config.language === "ts";
+  const imports = esm
+    ? `import { PrismaClient } from "@prisma/client";`
+    : `const { PrismaClient } = require("@prisma/client");`;
+
+  return `${imports}
+
+const prisma = new PrismaClient();
+
+async function connect() {
+  await prisma.$connect();
+  console.log("[db] prisma connected");
+}
+
+async function disconnect() {
+  await prisma.$disconnect();
+}
+
+${esm ? "export { prisma, connect, disconnect };" : "module.exports = { prisma, connect, disconnect };"}
+`;
+}
+
+module.exports = { generateSchemaPrisma, generatePrismaDbConfig };

package/src/generators/engine.js

@@ -0,0 +1,88 @@
+"use strict";
+
+const fs = require("fs-extra");
+const path = require("path");
+
+/**
+ * Thin, composable filesystem primitives used by every generator.
+ * Generators never call `fs` directly — everything funnels through here
+ * so behaviour (idempotency, logging, dry-run, etc.) stays centralized.
+ */
+class GeneratorEngine {
+  constructor(rootDir) {
+    this.rootDir = rootDir;
+    this.createdFiles = [];
+  }
+
+  resolve(...segments) {
+    return path.join(this.rootDir, ...segments);
+  }
+
+  createDirectory(relativePath) {
+    const full = this.resolve(relativePath);
+    fs.ensureDirSync(full);
+    return full;
+  }
+
+  createFile(relativePath, content) {
+    const full = this.resolve(relativePath);
+    fs.ensureDirSync(path.dirname(full));
+    fs.writeFileSync(full, content, "utf8");
+    this.createdFiles.push(relativePath);
+    return full;
+  }
+
+  fileExists(relativePath) {
+    return fs.existsSync(this.resolve(relativePath));
+  }
+
+  readJson(relativePath) {
+    return fs.readJsonSync(this.resolve(relativePath));
+  }
+
+  writeJson(relativePath, data) {
+    const full = this.resolve(relativePath);
+    fs.ensureDirSync(path.dirname(full));
+    fs.writeJsonSync(full, data, { spaces: 2 });
+    this.createdFiles.push(relativePath);
+    return full;
+  }
+
+  mergeJson(relativePath, patch) {
+    const existing = this.fileExists(relativePath) ? this.readJson(relativePath) : {};
+    const merged = deepMerge(existing, patch);
+    this.writeJson(relativePath, merged);
+    return merged;
+  }
+
+  /**
+   * Merge dependency/script/etc. fragments into package.json, preserving
+   * key ordering for the well-known top-level fields.
+   */
+  updatePackageJson(patch) {
+    const current = this.fileExists("package.json") ? this.readJson("package.json") : {};
+    const merged = deepMerge(current, patch);
+    this.writeJson("package.json", merged);
+    return merged;
+  }
+}
+
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceVal = source[key];
+    const targetVal = target[key];
+    if (isPlainObject(sourceVal) && isPlainObject(targetVal)) {
+      result[key] = deepMerge(targetVal, sourceVal);
+    } else {
+      result[key] = sourceVal;
+    }
+  }
+  return result;
+}
+
+module.exports = { GeneratorEngine, deepMerge };

package/src/generators/entity/sensitiveFields.js

@@ -0,0 +1,12 @@
+"use strict";
+
+// Field names matching this pattern are treated as sensitive and stripped from every API response
+// generated for a model's CRUD endpoints, regardless of database backend. This is a conservative,
+// name-based heuristic — not a replacement for review — documented in the README's limitations.
+const SENSITIVE_FIELD_PATTERN = /password|secret|hash/i;
+
+function getSensitiveFields(model) {
+  return model.fields.filter((f) => !f.primaryKey && SENSITIVE_FIELD_PATTERN.test(f.name)).map((f) => f.name);
+}
+
+module.exports = { getSensitiveFields, SENSITIVE_FIELD_PATTERN };

package/src/generators/entity/toApp.js

@@ -0,0 +1,325 @@
+"use strict";
+
+const { isEsm } = require("../syntax");
+const { sharedDir } = require("../paths");
+const { resolveImportPath } = require("../aliasResolver");
+const { getSensitiveFields } = require("./sensitiveFields");
+
+function serviceBody(model, config, sensitiveFields) {
+  const orm = config.database.orm;
+  const type = config.database.type;
+  const isTs = config.language === "ts";
+  const wrap = sensitiveFields.length > 0;
+
+  const dataParam = isTs ? "data: Record<string, unknown>" : "data";
+  const idParam = isTs ? "id: string" : "id";
+
+  // Password/secret/hash-like fields are stripped from every response a generated CRUD service
+  // returns, regardless of backend — see helpers/strip-sensitive-fields.
+  const one = (expr) => (wrap ? `stripSensitiveFields(${expr}, SENSITIVE_FIELDS)` : expr);
+  const many = (expr) => (wrap ? `stripSensitiveFieldsFromList(${expr}, SENSITIVE_FIELDS)` : expr);
+
+  if (type === "postgresql" && orm === "prisma") {
+    const ctor = isTs ? `constructor(private readonly db: PrismaClient = prisma) {}` : `constructor(db = prisma) {\n    this.db = db;\n  }`;
+    // Data is already shaped by the Zod validator at the route boundary; the cast here just
+    // bridges our generic service signature to Prisma's per-model input types.
+    const createData = isTs ? `data: data as Prisma.${model.pascalName}CreateInput` : "data";
+    const updateData = isTs ? `data: data as Prisma.${model.pascalName}UpdateInput` : "data";
+    return `class ${model.pascalName}Service {
+  ${ctor}
+
+  async create(${dataParam}) {
+    const record = await this.db.${model.camelName}.create({ ${createData} });
+    return ${one("record")};
+  }
+
+  async findAll() {
+    const records = await this.db.${model.camelName}.findMany();
+    return ${many("records")};
+  }
+
+  async findById(${idParam}) {
+    const record = await this.db.${model.camelName}.findUnique({ where: { ${model.primaryKey.camelName}: id } });
+    return ${one("record")};
+  }
+
+  async update(${idParam}, ${dataParam}) {
+    const record = await this.db.${model.camelName}.update({ where: { ${model.primaryKey.camelName}: id }, ${updateData} });
+    return ${one("record")};
+  }
+
+  async delete(${idParam}) {
+    return this.db.${model.camelName}.delete({ where: { ${model.primaryKey.camelName}: id } });
+  }
+}`;
+  }
+
+  if (type === "mongodb" && orm === "mongoose") {
+    const ctor = isTs
+      ? `constructor(private readonly model: Model<${model.pascalName}Document> = ${model.pascalName}) {}`
+      : `constructor(model = ${model.pascalName}) {\n    this.model = model;\n  }`;
+    return `class ${model.pascalName}Service {
+  ${ctor}
+
+  async create(${dataParam}) {
+    const record = await this.model.create(data);
+    return ${one("record")};
+  }
+
+  async findAll() {
+    const records = await this.model.find();
+    return ${many("records")};
+  }
+
+  async findById(${idParam}) {
+    const record = await this.model.findById(id);
+    return ${one("record")};
+  }
+
+  async update(${idParam}, ${dataParam}) {
+    const record = await this.model.findByIdAndUpdate(id, data, { new: true });
+    return ${one("record")};
+  }
+
+  async delete(${idParam}) {
+    return this.model.findByIdAndDelete(id);
+  }
+}`;
+  }
+
+  if (type === "mongodb" && orm === "native") {
+    // Mirrors the Mongoose _id strategy: the primary key is always Mongo's native `_id`, generated
+    // as a UUID string here (the driver has no schema-level default, so we generate it ourselves).
+    // The driver's default Collection<Document> types `_id` as ObjectId, so we type the collection
+    // against a document shape with a string `_id` instead of casting at every call site.
+    const collectionGeneric = isTs ? `<${model.pascalName}Doc>` : "";
+    return `class ${model.pascalName}Service {
+  collection() {
+    return getDb().collection${collectionGeneric}("${model.tableName}");
+  }
+
+  async create(${dataParam}) {
+    const doc = { _id: randomUUID(), ...data };
+    await this.collection().insertOne(doc);
+    return ${one("doc")};
+  }
+
+  async findAll() {
+    const records = await this.collection().find().toArray();
+    return ${many("records")};
+  }
+
+  async findById(${idParam}) {
+    const record = await this.collection().findOne({ _id: id });
+    return ${one("record")};
+  }
+
+  async update(${idParam}, ${dataParam}) {
+    await this.collection().updateOne({ _id: id }, { $set: data });
+    return this.findById(id);
+  }
+
+  async delete(${idParam}) {
+    const result = await this.collection().deleteOne({ _id: id });
+    return result.deletedCount > 0;
+  }
+}`;
+  }
+
+  // No database configured: in-memory store so entity.json can still be scaffolded end-to-end.
+  const storeFields = isTs
+    ? `private store = new Map<string, Record<string, unknown>>();\n  private seq = 1;`
+    : `constructor() {\n    this.store = new Map();\n    this.seq = 1;\n  }`;
+
+  return `class ${model.pascalName}Service {
+  ${storeFields}
+
+  async create(${dataParam}) {
+    const id = String(this.seq++);
+    const record = { id, ...data };
+    this.store.set(id, record);
+    return ${one("record")};
+  }
+
+  async findAll() {
+    return ${many("Array.from(this.store.values())")};
+  }
+
+  async findById(${idParam}) {
+    const record = this.store.get(id) || null;
+    return ${one("record")};
+  }
+
+  async update(${idParam}, ${dataParam}) {
+    const existing = this.store.get(id);
+    if (!existing) return null;
+    const updated = { ...existing, ...data };
+    this.store.set(id, updated);
+    return ${one("updated")};
+  }
+
+  async delete(${idParam}) {
+    return this.store.delete(id);
+  }
+}`;
+}
+
+function generateService(model, config, aliasConfig, dirs) {
+  const esm = isEsm(config);
+  const isTs = config.language === "ts";
+  const type = config.database.type;
+  const orm = config.database.orm;
+  const fromDir = dirs.services;
+  const r = (target) => resolveImportPath(config, aliasConfig, fromDir, target);
+
+  const dbFile = `${sharedDir(config, "configs")}/db/index`;
+  const dbPath = r(dbFile);
+
+  const imports = [];
+  if (type === "postgresql" && orm === "prisma") {
+    imports.push(esm ? `import { prisma } from "${dbPath}";` : `const { prisma } = require("${dbPath}");`);
+    if (isTs) imports.push(`import { PrismaClient, Prisma } from "@prisma/client";`);
+  } else if (type === "mongodb" && orm === "mongoose") {
+    const modelFile = `${sharedDir(config, "models")}/${model.kebabName}.model`;
+    const modelPath = r(modelFile);
+    const names = isTs ? `${model.pascalName}, ${model.pascalName}Document` : model.pascalName;
+    imports.push(esm ? `import { ${names} } from "${modelPath}";` : `const { ${names} } = require("${modelPath}");`);
+    if (isTs) imports.push(`import { Model } from "mongoose";`);
+  } else if (type === "mongodb" && orm === "native") {
+    imports.push(esm ? `import { getDb } from "${dbPath}";` : `const { getDb } = require("${dbPath}");`);
+    imports.push(esm ? `import { randomUUID } from "node:crypto";` : `const { randomUUID } = require("node:crypto");`);
+    if (isTs) imports.push(`\ninterface ${model.pascalName}Doc {\n  _id: string;\n  [key: string]: unknown;\n}`);
+  }
+
+  const sensitiveFields = getSensitiveFields(model);
+  if (sensitiveFields.length > 0) {
+    const helperPath = r(`${sharedDir(config, "helpers")}/strip-sensitive-fields`);
+    imports.push(
+      esm
+        ? `import { stripSensitiveFields, stripSensitiveFieldsFromList } from "${helperPath}";`
+        : `const { stripSensitiveFields, stripSensitiveFieldsFromList } = require("${helperPath}");`
+    );
+    imports.push(`const SENSITIVE_FIELDS = ${JSON.stringify(sensitiveFields)};`);
+  }
+
+  const body = serviceBody(model, config, sensitiveFields);
+  const footer = esm ? `\n\nexport { ${model.pascalName}Service };` : `\n\nmodule.exports = ${model.pascalName}Service;`;
+
+  return `${imports.join("\n")}${imports.length ? "\n\n" : ""}${body}${footer}\n`;
+}
+
+function generateController(model, config, aliasConfig, dirs) {
+  const esm = isEsm(config);
+  const isTs = config.language === "ts";
+  const reqType = isTs ? `import { Request, Response, NextFunction } from "express";\n` : "";
+
+  let serviceImport = "";
+  if (isTs) {
+    const servicePath = resolveImportPath(config, aliasConfig, dirs.controllers, `${dirs.services}/${model.kebabName}.service`);
+    serviceImport = `import { ${model.pascalName}Service } from "${servicePath}";\n`;
+  }
+
+  const ctorParam = isTs ? `private readonly service: ${model.pascalName}Service` : "service";
+  const handlerSig = isTs ? "async (req: Request, res: Response, next: NextFunction)" : "async (req, res, next)";
+  const serviceRef = "this.service";
+
+  const classKw = esm ? "export class" : "class";
+
+  const ctorBody = isTs ? "" : `\n    this.service = service;`;
+
+  return `${reqType}${serviceImport}${reqType || serviceImport ? "\n" : ""}${classKw} ${model.pascalName}Controller {
+  constructor(${ctorParam}) {${ctorBody}
+  }
+
+  create = ${handlerSig} => {
+    try {
+      const item = await ${serviceRef}.create(req.body);
+      return res.status(201).json({ success: true, data: item });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  findAll = ${handlerSig} => {
+    try {
+      const items = await ${serviceRef}.findAll();
+      return res.status(200).json({ success: true, data: items });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  findOne = ${handlerSig} => {
+    try {
+      const item = await ${serviceRef}.findById(req.params.id);
+      return res.status(200).json({ success: true, data: item });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  update = ${handlerSig} => {
+    try {
+      const item = await ${serviceRef}.update(req.params.id, req.body);
+      return res.status(200).json({ success: true, data: item });
+    } catch (error) {
+      next(error);
+    }
+  };
+
+  remove = ${handlerSig} => {
+    try {
+      await ${serviceRef}.delete(req.params.id);
+      return res.status(204).send();
+    } catch (error) {
+      next(error);
+    }
+  };
+}
+${esm ? "" : `\nmodule.exports = ${model.pascalName}Controller;\n`}`;
+}
+
+function generateRoutes(model, config, aliasConfig, dirs) {
+  const esm = isEsm(config);
+  const routesDir = dirs.routes;
+  const r = (target) => resolveImportPath(config, aliasConfig, routesDir, target);
+
+  const controllerPath = r(`${dirs.controllers}/${model.kebabName}.controller`);
+  const servicePath = r(`${dirs.services}/${model.kebabName}.service`);
+  const validatorPath = r(`${dirs.validators}/${model.kebabName}.validator`);
+  const validatePath = r(`${sharedDir(config, "middlewares")}/validate`);
+
+  const imports = esm
+    ? [
+        `import { Router } from "express";`,
+        `import { validate } from "${validatePath}";`,
+        `import { ${model.pascalName}Controller } from "${controllerPath}";`,
+        `import { ${model.pascalName}Service } from "${servicePath}";`,
+        `import { create${model.pascalName}Schema, update${model.pascalName}Schema } from "${validatorPath}";`,
+      ]
+    : [
+        `const { Router } = require("express");`,
+        `const { validate } = require("${validatePath}");`,
+        `const ${model.pascalName}Controller = require("${controllerPath}");`,
+        `const ${model.pascalName}Service = require("${servicePath}");`,
+        `const { create${model.pascalName}Schema, update${model.pascalName}Schema } = require("${validatorPath}");`,
+      ];
+
+  const body = `const router = Router();
+
+const service = new ${model.pascalName}Service();
+const controller = new ${model.pascalName}Controller(service);
+
+router.post("/", validate(create${model.pascalName}Schema), controller.create);
+router.get("/", controller.findAll);
+router.get("/:id", controller.findOne);
+router.patch("/:id", validate(update${model.pascalName}Schema), controller.update);
+router.delete("/:id", controller.remove);
+`;
+
+  const footer = esm ? "\nexport default router;\n" : "\nmodule.exports = router;\n";
+
+  return `${imports.join("\n")}\n\n${body}${footer}`;
+}
+
+module.exports = { generateService, generateController, generateRoutes };

package/src/generators/entity/toMongoose.js

@@ -0,0 +1,180 @@
+"use strict";
+
+const MONGOOSE_TYPE_MAP = {
+  string: "String",
+  text: "String",
+  number: "Number",
+  integer: "Number",
+  float: "Number",
+  boolean: "Boolean",
+  date: "Date",
+  datetime: "Date",
+  uuid: "String",
+  json: "mongoose.Schema.Types.Mixed",
+  enum: "String",
+  decimal: "mongoose.Schema.Types.Decimal128",
+  bigint: "mongoose.Schema.Types.Mixed",
+};
+
+function buildFieldDefinition(model, field, allModels) {
+  const belongsTo = model.relations.find((r) => r.type === "belongsTo" && r.foreignKey === field.name);
+  const props = [];
+
+  if (belongsTo) {
+    const target = allModels.find((m) => m.name === belongsTo.model);
+    // Every Mongo primary key is a String UUID (see buildIdOverride), so the FK referencing it
+    // must be String too — mongoose.Schema.Types.ObjectId would throw a CastError on every write.
+    props.push(`type: String`);
+    if (target) props.push(`ref: "${target.pascalName}"`);
+  } else {
+    props.push(`type: ${MONGOOSE_TYPE_MAP[field.type]}`);
+    if (field.type === "enum") props.push(`enum: ${JSON.stringify(field.values)}`);
+  }
+
+  if (field.required) props.push(`required: true`);
+  if (field.unique) props.push(`unique: true`);
+  if (field.index && !field.unique) props.push(`index: true`);
+  if (field.default !== undefined && field.default !== null && field.default !== "uuid") {
+    props.push(`default: ${JSON.stringify(field.default)}`);
+  }
+  if (field.min !== undefined) props.push(`min: ${field.min}`);
+  if (field.max !== undefined) props.push(`max: ${field.max}`);
+  if (field.length !== undefined) props.push(`maxlength: ${field.length}`);
+
+  return `    ${field.camelName}: { ${props.join(", ")} },`;
+}
+
+/**
+ * Entity validation guarantees that a MongoDB model's primary key, if declared explicitly, is
+ * always type 'uuid' (anything else — including autoIncrement — is rejected at parse time since
+ * Mongo has no native equivalent). So rather than emitting a redundant parallel 'id' field next to
+ * Mongo's native `_id`, we always route the primary key through `_id` itself: overriding its type
+ * to a generated UUID string. This is the one documented strategy GAZAN uses for Mongo primary
+ * keys — see README's MongoDB section.
+ */
+function buildIdOverride() {
+  return `    _id: { type: String, default: () => randomUUID() },`;
+}
+
+/**
+ * belongsToMany has no scalar FK column to hang off buildFieldDefinition (it only walks
+ * model.fields) — Mongoose represents it as its own array-of-refs field instead.
+ */
+function buildManyToManyFields(model, allModels) {
+  const lines = [];
+  for (const relation of model.relations) {
+    if (relation.type !== "belongsToMany") continue;
+    const target = allModels.find((m) => m.name === relation.model);
+    if (!target) continue;
+    lines.push(`    ${relation.camelName}: { type: [String], ref: "${target.pascalName}", default: [] },`);
+  }
+  return lines;
+}
+
+function buildVirtuals(model, allModels) {
+  const lines = [];
+  for (const relation of model.relations) {
+    if (relation.type === "hasMany" || relation.type === "hasOne") {
+      const target = allModels.find((m) => m.name === relation.model);
+      if (!target) continue;
+      lines.push(`${model.camelName}Schema.virtual("${relation.name}", {`);
+      lines.push(`  ref: "${target.pascalName}",`);
+      lines.push(`  localField: "_id",`);
+      lines.push(`  foreignField: "${relation.foreignKey}",`);
+      lines.push(`  justOne: ${relation.type === "hasOne"},`);
+      lines.push(`});`);
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+
+function generateMongooseModel(model, allModels, config) {
+  const nonPkFields = model.fields.filter((f) => !f.primaryKey);
+  const fieldLines = [
+    buildIdOverride(),
+    ...nonPkFields.map((f) => buildFieldDefinition(model, f, allModels)),
+    ...buildManyToManyFields(model, allModels),
+  ].join("\n");
+
+  const virtuals = buildVirtuals(model, allModels);
+  const isTs = config.language === "ts";
+  const esm = config.moduleSystem === "mjs" || isTs;
+
+  const cryptoImport = esm ? `import { randomUUID } from "node:crypto";` : `const { randomUUID } = require("node:crypto");`;
+  const mongooseImport = isTs
+    ? `import mongoose, { Document } from "mongoose";`
+    : config.moduleSystem === "mjs"
+    ? `import mongoose from "mongoose";`
+    : `const mongoose = require("mongoose");`;
+
+  const header = `${mongooseImport}\n${cryptoImport}\n`;
+
+  const interfaceBlock = isTs ? buildTsInterface(model) : "";
+
+  const schemaBody = [
+    `const ${model.camelName}Schema = new mongoose.Schema(`,
+    `  {`,
+    fieldLines,
+    `  },`,
+    `  {`,
+    `    timestamps: ${model.timestamps},`,
+    `    collection: "${model.tableName}",`,
+    `  }`,
+    `);`,
+    ``,
+    virtuals ? virtuals : "",
+    `${model.camelName}Schema.set("toJSON", { virtuals: true });`,
+    ``,
+  ]
+    .filter((l) => l !== "")
+    .join("\n");
+
+  const exportBlock = isTs
+    ? `export const ${model.pascalName} = mongoose.model<${model.pascalName}Document>("${model.pascalName}", ${model.camelName}Schema);\n`
+    : config.moduleSystem === "mjs"
+    ? `export const ${model.pascalName} = mongoose.model("${model.pascalName}", ${model.camelName}Schema);\n`
+    : `const ${model.pascalName} = mongoose.model("${model.pascalName}", ${model.camelName}Schema);\n\nmodule.exports = ${model.pascalName};\n`;
+
+  return [header, interfaceBlock, schemaBody, exportBlock].filter(Boolean).join("\n");
+}
+
+const TS_TYPE_MAP = {
+  string: "string",
+  text: "string",
+  number: "number",
+  integer: "number",
+  float: "number",
+  boolean: "boolean",
+  date: "Date",
+  datetime: "Date",
+  uuid: "string",
+  json: "Record<string, unknown>",
+  enum: "string",
+  decimal: "number",
+  bigint: "number",
+};
+
+function buildTsInterface(model) {
+  // Document<string, ...> types this model's `_id` (and the `.id` virtual) as a string, matching
+  // the UUID primary key strategy above — Mongoose's default `Document` types `_id` as an ObjectId.
+  const lines = [`export interface ${model.pascalName}Document extends Document<string> {`];
+  for (const field of model.fields) {
+    if (field.primaryKey) continue;
+    const optional = field.required ? "" : "?";
+    lines.push(`  ${field.camelName}${optional}: ${TS_TYPE_MAP[field.type]};`);
+  }
+  for (const relation of model.relations) {
+    if (relation.type === "belongsToMany") {
+      lines.push(`  ${relation.camelName}: string[];`);
+    }
+  }
+  if (model.timestamps) {
+    lines.push(`  createdAt: Date;`);
+    lines.push(`  updatedAt: Date;`);
+  }
+  lines.push(`}`);
+  return lines.join("\n") + "\n";
+}
+
+module.exports = { generateMongooseModel };