metal-orm 1.0.48 → 1.0.50

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metal-orm",
-  "version": "1.0.48",
+  "version": "1.0.50",
   "type": "module",
   "types": "./dist/index.d.ts",
   "engines": {

package/scripts/generate-entities/cli.mjs

@@ -0,0 +1,198 @@
+import fs from 'node:fs';
+import process from 'node:process';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { parseArgs as parseCliArgs } from 'node:util';
+
+const DIALECTS = new Set(['postgres', 'mysql', 'sqlite', 'mssql']);
+const NODE_NEXT_MODULE_RESOLUTIONS = new Set(['node16', 'nodenext']);
+
+const TS_CONFIG_BASE_NAMES = ['tsconfig.json', 'tsconfig.base.json', 'tsconfig.app.json', 'tsconfig.build.json'];
+const nodeRequire = createRequire(import.meta.url);
+
+const normalizeCompilerOption = value => (typeof value === 'string' ? value.trim().toLowerCase() : '');
+
+const hasNodeNextModuleResolution = compilerOptions => {
+  if (!compilerOptions || typeof compilerOptions !== 'object') return false;
+  const moduleResolution = normalizeCompilerOption(compilerOptions.moduleResolution);
+  const moduleOption = normalizeCompilerOption(compilerOptions.module);
+  return (
+    NODE_NEXT_MODULE_RESOLUTIONS.has(moduleResolution) || NODE_NEXT_MODULE_RESOLUTIONS.has(moduleOption)
+  );
+};
+
+const resolveExtendsPath = (extendsValue, baseDir) => {
+  if (!extendsValue || typeof extendsValue !== 'string') return undefined;
+  const candidatePaths = [];
+  const normalizedValue = extendsValue.trim();
+  candidatePaths.push(path.resolve(baseDir, normalizedValue));
+  if (!path.extname(normalizedValue)) {
+    candidatePaths.push(`${path.resolve(baseDir, normalizedValue)}.json`);
+  }
+  for (const candidate of candidatePaths) {
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  try {
+    return nodeRequire.resolve(normalizedValue, { paths: [baseDir] });
+  } catch {
+    return undefined;
+  }
+};
+
+const inspectTsConfig = (configPath, visited) => {
+  if (!configPath) return false;
+  const normalized = path.resolve(configPath);
+  if (visited.has(normalized)) return false;
+  if (!fs.existsSync(normalized)) return false;
+  visited.add(normalized);
+  let raw;
+  try {
+    raw = fs.readFileSync(normalized, 'utf8');
+  } catch {
+    return false;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return false;
+  }
+  if (hasNodeNextModuleResolution(parsed.compilerOptions)) {
+    return true;
+  }
+  if (parsed.extends) {
+    const extended = resolveExtendsPath(parsed.extends, path.dirname(normalized));
+    if (extended && inspectTsConfig(extended, visited)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+const discoverTsConfigPaths = cwd => {
+  const candidates = new Set();
+  for (const name of TS_CONFIG_BASE_NAMES) {
+    const fullPath = path.join(cwd, name);
+    if (fs.existsSync(fullPath)) {
+      candidates.add(fullPath);
+    }
+  }
+  try {
+    const entries = fs.readdirSync(cwd);
+    for (const entry of entries) {
+      const lower = entry.toLowerCase();
+      if (lower.startsWith('tsconfig') && lower.endsWith('.json')) {
+        candidates.add(path.join(cwd, entry));
+      }
+    }
+  } catch {
+    // ignore readdir errors
+  }
+  return Array.from(candidates);
+};
+
+const shouldUseJsImportExtensions = cwd => {
+  const paths = discoverTsConfigPaths(cwd);
+  if (!paths.length) return false;
+  const visited = new Set();
+  for (const configPath of paths) {
+    if (inspectTsConfig(configPath, visited)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+export const parseOptions = (argv = process.argv.slice(2), env = process.env, cwd = process.cwd()) => {
+  const parser = {
+    options: {
+      dialect: { type: 'string' },
+      url: { type: 'string' },
+      db: { type: 'string' },
+      schema: { type: 'string' },
+      include: { type: 'string' },
+      exclude: { type: 'string' },
+      out: { type: 'string' },
+      locale: { type: 'string' },
+      'naming-overrides': { type: 'string' },
+      'dry-run': { type: 'boolean' },
+      'out-dir': { type: 'string' },
+      help: { type: 'boolean', short: 'h' },
+      version: { type: 'boolean' }
+    },
+    strict: true
+  };
+
+  const { values, positionals } = parseCliArgs(parser, { argv });
+
+  if (values.help) {
+    return { kind: 'help' };
+  }
+
+  if (values.version) {
+    return { kind: 'version' };
+  }
+
+  if (positionals.length) {
+    throw new Error(`Unexpected positional args: ${positionals.join(' ')}`);
+  }
+
+  const opts = {
+    dialect: (values.dialect || 'postgres').toLowerCase(),
+    url: values.url || env.DATABASE_URL,
+    dbPath: values.db,
+    schema: values.schema,
+    include: values.include ? values.include.split(',').map(v => v.trim()).filter(Boolean) : undefined,
+    exclude: values.exclude ? values.exclude.split(',').map(v => v.trim()).filter(Boolean) : undefined,
+    out: values.out ? path.resolve(cwd, values.out) : undefined,
+    outDir: values['out-dir'] ? path.resolve(cwd, values['out-dir']) : undefined,
+    locale: (values.locale || 'en').toLowerCase(),
+    namingOverrides: values['naming-overrides'] ? path.resolve(cwd, values['naming-overrides']) : undefined,
+    dryRun: Boolean(values['dry-run'])
+  };
+
+  opts.useJsImportExtensions = shouldUseJsImportExtensions(cwd);
+
+  if (!DIALECTS.has(opts.dialect)) {
+    throw new Error(`Unsupported dialect "${opts.dialect}". Supported: ${Array.from(DIALECTS).join(', ')}`);
+  }
+
+  if (opts.dialect === 'sqlite' && !opts.dbPath) {
+    opts.dbPath = ':memory:';
+  }
+
+  if (opts.dialect !== 'sqlite' && !opts.url) {
+    throw new Error('Missing connection string. Provide --url or set DATABASE_URL.');
+  }
+
+  if (!opts.out) {
+    opts.out = opts.outDir ? path.join(opts.outDir, 'index.ts') : path.join(cwd, 'generated-entities.ts');
+  }
+
+  return { kind: 'generate', options: opts };
+};
+
+export const printUsage = () => {
+  console.log(
+    `
+MetalORM decorator generator
+---------------------------
+Usage:
+  node scripts/generate-entities.mjs --dialect=postgres --url=<connection> --schema=public --include=users,orders [--out=src/entities.ts]
+  node scripts/generate-entities.mjs --dialect=mysql     --url=<connection> --schema=mydb --exclude=archived [--out=src/entities.ts]
+  node scripts/generate-entities.mjs --dialect=sqlite    --db=./my.db                           [--out=src/entities.ts]
+  node scripts/generate-entities.mjs --dialect=mssql     --url=mssql://user:pass@host/db        [--out=src/entities.ts]
+  node scripts/generate-entities.mjs --dialect=postgres --url=<connection> --schema=public --out-dir=src/entities
+
+Flags:
+  --include=tbl1,tbl2   Only include these tables
+  --exclude=tbl3,tbl4   Exclude these tables
+  --locale=pt-BR        Naming locale for class/relation names (default: en)
+  --naming-overrides    Path to JSON map of irregular plurals { "singular": "plural" }
+  --dry-run             Print to stdout instead of writing a file
+  --out=<file>          Override the generated file (defaults to generated-entities.ts or the index inside --out-dir)
+  --out-dir=<dir>       Emit one file per entity inside this directory plus the shared index
+  --help                Show this help
+`
+  );
+};

package/scripts/generate-entities/drivers.mjs

@@ -0,0 +1,183 @@
+import { createPostgresExecutor, createMysqlExecutor, createSqliteExecutor, createMssqlExecutor } from '../../dist/index.js';
+
+const parseSqlServerOptionValue = value => {
+  if (!value) return value;
+  if (/^-?\d+$/.test(value)) return Number(value);
+  if (/^(true|false)$/i.test(value)) return value.toLowerCase() === 'true';
+  return value;
+};
+
+const parseSqlServerConnectionConfig = connectionString => {
+  if (!connectionString) {
+    throw new Error('Missing connection string for SQL Server');
+  }
+  const url = new URL(connectionString);
+  const config = {
+    server: url.hostname,
+    authentication: {
+      type: 'default',
+      options: {
+        userName: decodeURIComponent(url.username || ''),
+        password: decodeURIComponent(url.password || '')
+      }
+    },
+    options: {}
+  };
+
+  const database = url.pathname ? url.pathname.replace(/^\//, '') : '';
+  if (database) {
+    config.options.database = database;
+  }
+  if (url.port) {
+    config.options.port = Number(url.port);
+  }
+
+  for (const [key, value] of url.searchParams) {
+    config.options[key] = parseSqlServerOptionValue(value);
+  }
+
+  return config;
+};
+
+const getTediousParameterType = (value, TYPES) => {
+  if (value === null || value === undefined) {
+    return TYPES.NVarChar;
+  }
+  if (typeof value === 'number') {
+    return Number.isInteger(value) ? TYPES.Int : TYPES.Float;
+  }
+  if (typeof value === 'bigint') {
+    return TYPES.BigInt;
+  }
+  if (typeof value === 'boolean') {
+    return TYPES.Bit;
+  }
+  if (value instanceof Date) {
+    return TYPES.DateTime;
+  }
+  if (Buffer.isBuffer(value)) {
+    return TYPES.VarBinary;
+  }
+  return TYPES.NVarChar;
+};
+
+export const loadDriver = async (dialect, url, dbPath) => {
+  switch (dialect) {
+    case 'postgres': {
+      const mod = await import('pg');
+      const { Client } = mod;
+      const client = new Client({ connectionString: url });
+      await client.connect();
+      const executor = createPostgresExecutor(client);
+      return { executor, cleanup: async () => client.end() };
+    }
+    case 'mysql': {
+      const mod = await import('mysql2/promise');
+      const conn = await mod.createConnection(url);
+      const executor = createMysqlExecutor({
+        query: (...args) => conn.execute(...args),
+        beginTransaction: () => conn.beginTransaction(),
+        commit: () => conn.commit(),
+        rollback: () => conn.rollback()
+      });
+      return { executor, cleanup: async () => conn.end() };
+    }
+    case 'sqlite': {
+      const mod = await import('sqlite3');
+      const sqlite3 = mod.default || mod;
+      const db = new sqlite3.Database(dbPath);
+      const execAll = (sql, params) =>
+        new Promise((resolve, reject) => {
+          db.all(sql, params || [], (err, rows) => {
+            if (err) return reject(err);
+            resolve(rows);
+          });
+        });
+      const executor = createSqliteExecutor({
+        all: execAll,
+        beginTransaction: () => execAll('BEGIN'),
+        commitTransaction: () => execAll('COMMIT'),
+        rollbackTransaction: () => execAll('ROLLBACK')
+      });
+      const cleanup = async () =>
+        new Promise((resolve, reject) => db.close(err => (err ? reject(err) : resolve())));
+      return { executor, cleanup };
+    }
+    case 'mssql': {
+      const mod = await import('tedious');
+      const { Connection, Request, TYPES } = mod;
+      const config = parseSqlServerConnectionConfig(url);
+      const connection = new Connection(config);
+
+      await new Promise((resolve, reject) => {
+        const onConnect = err => {
+          connection.removeListener('error', onError);
+          if (err) return reject(err);
+          resolve();
+        };
+        const onError = err => {
+          connection.removeListener('connect', onConnect);
+          reject(err);
+        };
+        connection.once('connect', onConnect);
+        connection.once('error', onError);
+        connection.connect();
+      });
+
+      const execQuery = (sql, params) =>
+        new Promise((resolve, reject) => {
+          const rows = [];
+          const request = new Request(sql, err => {
+            if (err) return reject(err);
+            resolve({ recordset: rows });
+          });
+          request.on('row', columns => {
+            const row = {};
+            for (const column of columns) {
+              row[column.metadata.colName] = column.value;
+            }
+            rows.push(row);
+          });
+          params?.forEach((value, index) => {
+            request.addParameter(`p${index + 1}`, getTediousParameterType(value, TYPES), value);
+          });
+          connection.execSql(request);
+        });
+
+      const executor = createMssqlExecutor({
+        query: execQuery,
+        beginTransaction: () =>
+          new Promise((resolve, reject) => {
+            connection.beginTransaction(err => (err ? reject(err) : resolve()));
+          }),
+        commit: () =>
+          new Promise((resolve, reject) => {
+            connection.commitTransaction(err => (err ? reject(err) : resolve()));
+          }),
+        rollback: () =>
+          new Promise((resolve, reject) => {
+            connection.rollbackTransaction(err => (err ? reject(err) : resolve()));
+          })
+      });
+
+      const cleanup = async () =>
+        new Promise((resolve, reject) => {
+          const onEnd = () => {
+            connection.removeListener('error', onError);
+            resolve();
+          };
+          const onError = err => {
+            connection.removeListener('end', onEnd);
+            reject(err);
+          };
+          connection.once('end', onEnd);
+          connection.once('error', onError);
+          connection.close();
+        });
+
+      return { executor, cleanup };
+    }
+    default:
+      throw new Error(`Unsupported dialect ${dialect}`);
+  }
+};

package/scripts/generate-entities/emit.mjs

@@ -0,0 +1,24 @@
+import path from 'node:path';
+
+export const writeSingleFile = async (fsPromises, out, code) => {
+  await fsPromises.mkdir(path.dirname(out), { recursive: true });
+  await fsPromises.writeFile(out, code, 'utf8');
+};
+
+export const writeSplitFiles = async (fsPromises, tableFiles, outDir, indexOut, indexCode) => {
+  await fsPromises.mkdir(outDir, { recursive: true });
+  for (const file of tableFiles) {
+    await fsPromises.writeFile(file.path, file.code, 'utf8');
+  }
+  await fsPromises.mkdir(path.dirname(indexOut), { recursive: true });
+  await fsPromises.writeFile(indexOut, indexCode, 'utf8');
+};
+
+export const printDryRun = (logger, tableFiles, indexCode, indexPath) => {
+  for (const file of tableFiles) {
+    logger.log(`\n==> ${file.path}\n`);
+    logger.log(file.code);
+  }
+  logger.log(`\n==> ${indexPath}\n`);
+  logger.log(indexCode);
+};

package/scripts/generate-entities/generate.mjs

@@ -0,0 +1,68 @@
+import fs from 'node:fs/promises';
+import { introspectSchema } from '../../dist/index.js';
+import { createNamingStrategy } from '../naming-strategy.mjs';
+import { loadDriver } from './drivers.mjs';
+import { renderEntityFile, renderSplitEntityFiles, renderSplitIndexFile } from './render.mjs';
+import { printDryRun, writeSingleFile, writeSplitFiles } from './emit.mjs';
+
+const loadIrregulars = async (filePath, fsPromises) => {
+  const raw = await fsPromises.readFile(filePath, 'utf8');
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`Failed to parse naming overrides at ${filePath}: ${err.message || err}`);
+  }
+  const irregulars =
+    parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+      ? parsed.irregulars && typeof parsed.irregulars === 'object' && !Array.isArray(parsed.irregulars)
+        ? parsed.irregulars
+        : parsed
+      : undefined;
+  if (!irregulars) {
+    throw new Error(`Naming overrides at ${filePath} must be an object or { "irregulars": { ... } }`);
+  }
+  return irregulars;
+};
+
+export const generateEntities = async (opts, context = {}) => {
+  const { fs: fsPromises = fs, logger = console } = context;
+  const irregulars = opts.namingOverrides ? await loadIrregulars(opts.namingOverrides, fsPromises) : undefined;
+  const naming = createNamingStrategy(opts.locale, irregulars);
+
+  const { executor, cleanup } = await loadDriver(opts.dialect, opts.url, opts.dbPath);
+  let schema;
+  try {
+    schema = await introspectSchema(executor, opts.dialect, {
+      schema: opts.schema,
+      includeTables: opts.include,
+      excludeTables: opts.exclude
+    });
+  } finally {
+    await cleanup?.();
+  }
+
+  if (opts.outDir) {
+    const { tableFiles, metadata } = renderSplitEntityFiles(schema, { ...opts, naming });
+    const indexCode = renderSplitIndexFile(metadata, { ...opts, naming });
+
+    if (opts.dryRun) {
+      printDryRun(logger, tableFiles, indexCode, opts.out);
+      return;
+    }
+
+    await writeSplitFiles(fsPromises, tableFiles, opts.outDir, opts.out, indexCode);
+    logger.log(`Wrote ${tableFiles.length} entity files to ${opts.outDir} and index ${opts.out} (${schema.tables.length} tables)`);
+    return;
+  }
+
+  const code = renderEntityFile(schema, { ...opts, naming });
+
+  if (opts.dryRun) {
+    logger.log(code);
+    return;
+  }
+
+  await writeSingleFile(fsPromises, opts.out, code);
+  logger.log(`Wrote ${opts.out} (${schema.tables.length} tables)`);
+};