orchid-orm 1.9.2 → 1.9.4

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { columnTypes, getColumnTypes, addQueryOn, VirtualColumn, pushQueryValue, isQueryReturnsAll, getQueryAs, toSqlCacheKey, NotFoundError, relationQueryKey, Adapter, Db, anyShape, getClonedQueryData, columnsShapeToCode, primaryKeyToCode, indexToCode, constraintToCode, columnIndexesToCode, columnForeignKeysToCode, columnCheckToCode, identityToCode } from 'pqb';
+import { columnTypes, getColumnTypes, addQueryOn, VirtualColumn, pushQueryValue, isQueryReturnsAll, getQueryAs, toSqlCacheKey, NotFoundError, relationQueryKey, Adapter, Db, anyShape, getClonedQueryData, columnsShapeToCode, ColumnType, primaryKeyToCode, indexToCode, constraintToCode, columnIndexesToCode, columnForeignKeysToCode, columnCheckToCode, identityToCode } from 'pqb';
 export { OrchidOrmError, OrchidOrmInternalError, columnTypes } from 'pqb';
 import { getCallerFilePath, snakeCaseKey, toSnakeCase, emptyObject, pathToLog, toCamelCase, toPascalCase, getImportPath, singleQuote, codeToString, quoteObjectKey, addCode, columnDefaultArgumentToCode, deepCompare } from 'orchid-core';
 import { AsyncLocalStorage } from 'node:async_hooks';
@@ -6,6 +6,7 @@ import * as path from 'path';
 import path__default from 'path';
 import fs from 'fs/promises';
 import typescript from 'typescript';
+import { pluralize } from 'inflection';
 
 const createBaseTable = ({
   columnTypes: columnTypes$1,
@@ -30,26 +31,35 @@ const create = (columnTypes, filePath, snakeCase) => {
   const base = (_a = class {
     constructor() {
       this.snakeCase = snakeCase;
-      this.setColumns = (fn) => {
-        columnTypes[snakeCaseKey] = this.snakeCase;
-        const shape = getColumnTypes(columnTypes, fn);
-        if (this.snakeCase) {
-          for (const key in shape) {
-            const column = shape[key];
-            if (column.data.name)
-              continue;
-            const snakeName = toSnakeCase(key);
-            if (snakeName !== key) {
-              column.data.name = snakeName;
-            }
+      this.columnTypes = columnTypes;
+    }
+    setColumns(fn) {
+      if (!this.filePath) {
+        const filePath2 = getCallerFilePath();
+        if (!filePath2) {
+          throw new Error(
+            `Failed to determine file path for table ${this.constructor.name}. Please set \`filePath\` property manually`
+          );
+        }
+        this.filePath = filePath2;
+      }
+      columnTypes[snakeCaseKey] = this.snakeCase;
+      const shape = getColumnTypes(columnTypes, fn);
+      if (this.snakeCase) {
+        for (const key in shape) {
+          const column = shape[key];
+          if (column.data.name)
+            continue;
+          const snakeName = toSnakeCase(key);
+          if (snakeName !== key) {
+            column.data.name = snakeName;
           }
         }
-        return {
-          shape,
-          type: void 0
-        };
+      }
+      return {
+        shape,
+        type: void 0
       };
-      this.columnTypes = columnTypes;
     }
     belongsTo(fn, options) {
       return {
@@ -1386,6 +1396,8 @@ const orchidORM = (_a, tables) => {
     );
     dbTable.definedAs = key;
     dbTable.db = result;
+    dbTable.filePath = table.filePath;
+    dbTable.name = table.constructor.name;
     result[key] = dbTable;
   }
   applyRelations(qb, tableInstances, result);
@@ -1759,6 +1771,48 @@ const getTablesListObject = (importName, statements) => {
   return;
 };
 
+const handleForeignKey = async ({
+  getTable,
+  relations,
+  tableName,
+  columns,
+  foreignTableName,
+  foreignColumns,
+  skipBelongsTo
+}) => {
+  var _a, _b;
+  const table = await getTable(tableName);
+  if (!table)
+    return;
+  const foreignTable = await getTable(foreignTableName);
+  if (!foreignTable)
+    return;
+  if (!skipBelongsTo) {
+    (_a = relations[tableName]) != null ? _a : relations[tableName] = {
+      path: table.path,
+      relations: []
+    };
+    relations[tableName].relations.push({
+      kind: "belongsTo",
+      columns,
+      className: foreignTable.name,
+      path: foreignTable.path,
+      foreignColumns
+    });
+  }
+  (_b = relations[foreignTableName]) != null ? _b : relations[foreignTableName] = {
+    path: foreignTable.path,
+    relations: []
+  };
+  relations[foreignTableName].relations.push({
+    kind: "hasMany",
+    columns: foreignColumns,
+    className: table.name,
+    path: table.path,
+    foreignColumns: columns
+  });
+};
+
 var __getOwnPropSymbols$4 = Object.getOwnPropertySymbols;
 var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
 var __propIsEnum$4 = Object.prototype.propertyIsEnumerable;
@@ -1777,13 +1831,29 @@ var __objRest$2 = (source, exclude) => {
 const createTable = async (_a) => {
   var _b = _a, {
     ast,
-    logger
+    logger,
+    getTable,
+    relations,
+    tables
   } = _b, params = __objRest$2(_b, [
     "ast",
-    "logger"
+    "logger",
+    "getTable",
+    "relations",
+    "tables"
   ]);
-  const tablePath = params.tablePath(toCamelCase(ast.name));
+  const key = toCamelCase(ast.name);
+  const tablePath = params.tablePath(key);
   const baseTablePath = getImportPath(tablePath, params.baseTable.filePath);
+  const className = `${toPascalCase(ast.name)}Table`;
+  tables[ast.name] = {
+    key,
+    name: className,
+    path: tablePath
+  };
+  const imports = {
+    [baseTablePath]: params.baseTable.name
+  };
   const props = [];
   if (ast.schema) {
     props.push(`schema = ${singleQuote(ast.schema)};`);
@@ -1797,10 +1867,23 @@ const createTable = async (_a) => {
     columnsShapeToCode(ast.shape, ast, "t"),
     "}));"
   );
+  const relCode = await getRelations(
+    ast,
+    getTable,
+    tablePath,
+    imports,
+    relations,
+    ast.name
+  );
+  if (relCode) {
+    props.push("", ...relCode);
+  }
   const code = [
-    `import { ${params.baseTable.name} } from '${baseTablePath}';
-`,
-    `export class ${toPascalCase(ast.name)}Table extends ${params.baseTable.name} {`,
+    ...Object.entries(imports).map(
+      ([from, name]) => `import { ${name} } from '${from}';`
+    ),
+    "",
+    `export class ${className} extends ${params.baseTable.name} {`,
     props,
     "}\n"
   ];
@@ -1814,6 +1897,62 @@ const createTable = async (_a) => {
     }
   }
 };
+const getRelations = async (ast, getTable, tablePath, imports, relations, tableName) => {
+  const refs = [];
+  for (const key in ast.shape) {
+    const item = ast.shape[key];
+    if (!(item instanceof ColumnType) || !item.data.foreignKeys)
+      continue;
+    for (const fkey of item.data.foreignKeys) {
+      if ("table" in fkey) {
+        refs.push({
+          table: fkey.table,
+          columns: [key],
+          foreignColumns: fkey.columns
+        });
+      }
+    }
+  }
+  if (ast.constraints) {
+    for (const { references: ref } of ast.constraints) {
+      if (ref && typeof ref.fnOrTable === "string") {
+        refs.push({
+          table: ref.fnOrTable,
+          columns: ref.columns,
+          foreignColumns: ref.foreignColumns
+        });
+      }
+    }
+  }
+  if (!refs.length)
+    return;
+  const code = [];
+  for (const ref of refs) {
+    const { columns, foreignColumns } = ref;
+    if (columns.length > 1 || foreignColumns.length > 1)
+      continue;
+    const info = await getTable(ref.table);
+    if (!info)
+      continue;
+    const path2 = getImportPath(tablePath, info.path);
+    imports[path2] = info.name;
+    code.push(
+      `${info.key}: this.belongsTo(() => ${info.name}, {`,
+      [`primaryKey: '${foreignColumns[0]}',`, `foreignKey: '${columns[0]}',`],
+      "}),"
+    );
+    await handleForeignKey({
+      getTable,
+      relations,
+      tableName,
+      columns: ref.columns,
+      foreignTableName: ref.table,
+      foreignColumns: ref.foreignColumns,
+      skipBelongsTo: true
+    });
+  }
+  return code.length ? ["relations = {", code, "};"] : void 0;
+};
 
 var __defProp$2 = Object.defineProperty;
 var __getOwnPropSymbols$3 = Object.getOwnPropertySymbols;
@@ -2408,6 +2547,18 @@ const updateTableFile = async (params) => {
     await changeTable(__spreadProps$1(__spreadValues$1({}, params), { ast }));
   } else if (ast.type === "renameTable") {
     await renameTable(__spreadProps$1(__spreadValues$1({}, params), { ast }));
+  } else if (ast.type === "constraint" && ast.references) {
+    const ref = ast.references;
+    if (typeof ref.fnOrTable === "string") {
+      await handleForeignKey({
+        getTable: params.getTable,
+        relations: params.relations,
+        tableName: ast.tableName,
+        columns: ref.columns,
+        foreignTableName: ref.fnOrTable,
+        foreignColumns: ref.foreignColumns
+      });
+    }
   }
 };
 
@@ -2434,6 +2585,131 @@ export const ${baseTable.name} = createBaseTable();
   });
 };
 
+const updateRelations = async ({
+  relations,
+  logger
+}) => {
+  await Promise.all(
+    Object.entries(relations).map(
+      ([tableName, item]) => updateRelationItem(tableName, item, logger)
+    )
+  );
+};
+const updateRelationItem = async (tableName, item, logger) => {
+  var _a;
+  const content = await fs.readFile(item.path, "utf-8").catch(() => void 0);
+  if (!content)
+    return;
+  const changes = new FileChanges(content);
+  const statements = ts.getStatements(content);
+  const dirName = path__default.dirname(item.path);
+  const imports = {};
+  for (const relation of item.relations) {
+    if (!imports[relation.path]) {
+      imports[relation.path] = relation.className;
+    }
+  }
+  let importsEnd = 0;
+  for (const node of ts.import.iterate(statements)) {
+    const source = ts.import.getSource(node);
+    const full = path__default.join(dirName, source + ".ts");
+    if (imports[full]) {
+      delete imports[full];
+    }
+    importsEnd = node.end;
+  }
+  const addImports = Object.entries(imports).map(
+    ([path2, name]) => `import { ${name} } from '${getImportPath(item.path, path2)}';`
+  ).join("\n");
+  if (addImports) {
+    changes.add(importsEnd, `
+${addImports}`);
+  }
+  const targetClass = findClassByTableName(statements, tableName);
+  if (targetClass) {
+    const relationsMember = findRelationsMember(targetClass.members);
+    if (relationsMember) {
+      const { initializer } = relationsMember;
+      const takenKeys = {};
+      if (ts.is.objectLiteral(initializer)) {
+        const props = initializer.properties;
+        for (const prop of props) {
+          const name = (_a = prop.name) == null ? void 0 : _a.getText();
+          if (name)
+            takenKeys[name] = true;
+        }
+        const addRelations = [];
+        for (const rel of item.relations) {
+          if (!checkRelation(rel))
+            continue;
+          const name = makeRelationName(rel);
+          if (takenKeys[name])
+            continue;
+          addRelations.push(relationToCode(rel));
+        }
+        if (addRelations.length) {
+          const pos = props.end;
+          changes.add(pos, addRelations.join(""));
+        }
+      }
+    } else {
+      changes.add(
+        targetClass.end - 1,
+        `
+  relations = {${item.relations.filter(checkRelation).map((rel) => relationToCode(rel)).join("")}
+  };
+`
+      );
+    }
+  }
+  await fs.writeFile(item.path, changes.apply());
+  logger == null ? void 0 : logger.log(`Updated ${pathToLog(item.path)}`);
+};
+const findClassByTableName = (statements, tableName) => {
+  for (const node of ts.class.iterate(statements)) {
+    for (const member of node.members) {
+      const name = ts.prop.getName(member);
+      if (name !== "table")
+        continue;
+      const { initializer: value } = member;
+      if (!value || !ts.is.stringLiteral(value))
+        continue;
+      if (value.text === tableName) {
+        return node;
+      }
+    }
+  }
+  return;
+};
+const findRelationsMember = (members) => {
+  for (const member of members) {
+    const name = ts.prop.getName(member);
+    if (name === "relations")
+      return member;
+  }
+  return;
+};
+const checkRelation = (rel) => {
+  return rel.columns.length === 1 && rel.foreignColumns.length === 1;
+};
+const makeRelationName = (rel) => {
+  return pluralize(
+    rel.className[0].toLowerCase() + rel.className.slice(1).replace(/Table$/, "")
+  );
+};
+const relationToCode = (rel, name = makeRelationName(rel)) => {
+  const code = [`
+    ${name}: this.${rel.kind}(() => ${rel.className}, {`];
+  const pk = rel[rel.kind === "hasMany" ? "columns" : "foreignColumns"][0];
+  const fk = rel[rel.kind === "hasMany" ? "foreignColumns" : "columns"][0];
+  code.push(
+    `      primaryKey: '${pk}',`,
+    `      foreignKey: '${fk}',`,
+    "    }),"
+  );
+  return code.join("\n");
+};
+
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
 var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
@@ -2455,37 +2731,68 @@ var __spreadValues = (a, b) => {
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 class AppCodeUpdaterError extends Error {
 }
+const makeGetTable = (path2, ormExportedAs, tables) => {
+  let orm;
+  return async (tableName) => {
+    if (tables[tableName])
+      return tables[tableName];
+    if (!orm) {
+      orm = (await import(path2))[ormExportedAs];
+      if (!orm) {
+        throw new Error(`ORM is not exported as ${ormExportedAs} from ${path2}`);
+      }
+    }
+    for (const key in orm) {
+      const table = orm[key];
+      if (table && typeof table === "object" && table instanceof Db && table.table === tableName) {
+        const tableInfo = {
+          key,
+          name: table.name,
+          path: table.filePath
+        };
+        return tables[tableName] = tableInfo;
+      }
+    }
+    return;
+  };
+};
 const appCodeUpdater = ({
   tablePath,
-  mainFilePath
-}) => {
-  return async ({
+  ormPath,
+  ormExportedAs = "db"
+}) => ({
+  async process({
     ast,
     options,
     basePath,
     cache: cacheObject,
     logger,
     baseTable
-  }) => {
+  }) {
+    var _a, _b;
     const params = {
       tablePath(name) {
         const file = tablePath(name);
         return resolvePath(basePath, file);
       },
-      mainFilePath: resolvePath(basePath, mainFilePath),
+      ormPath: resolvePath(basePath, ormPath),
+      ormExportedAs,
       logger
     };
+    const cache = cacheObject;
+    (_a = cache.relations) != null ? _a : cache.relations = {};
+    (_b = cache.tables) != null ? _b : cache.tables = {};
+    const getTable = makeGetTable(params.ormPath, ormExportedAs, cache.tables);
     const promises = [
-      updateMainFile(
-        params.mainFilePath,
-        params.tablePath,
+      updateMainFile(params.ormPath, params.tablePath, ast, options, logger),
+      updateTableFile(__spreadProps(__spreadValues({}, params), {
         ast,
-        options,
-        logger
-      ),
-      updateTableFile(__spreadProps(__spreadValues({}, params), { ast, baseTable }))
+        baseTable,
+        getTable,
+        relations: cache.relations,
+        tables: cache.tables
+      }))
     ];
-    const cache = cacheObject;
     if (!cache.createdBaseTable) {
       promises.push(
         createBaseTableFile({ logger: params.logger, baseTable }).then(() => {
@@ -2494,8 +2801,17 @@ const appCodeUpdater = ({
       );
     }
     await Promise.all(promises);
-  };
-};
+  },
+  async afterAll({ cache, logger }) {
+    const { relations } = cache;
+    if (!relations)
+      return;
+    await updateRelations({
+      relations,
+      logger
+    });
+  }
+});
 const resolvePath = (basePath, filePath) => path.isAbsolute(filePath) ? filePath : path.resolve(basePath, filePath);
 
 export { AppCodeUpdaterError, appCodeUpdater, createBaseTable, createRepo, orchidORM };