orchid-orm 1.24.7 → 1.25.1

package/codegen/index.mjs

@@ -1,1439 +0,0 @@
-import * as path from 'path';
-import path__default from 'path';
-import fs from 'fs/promises';
-import typescript from 'typescript';
-import { pathToLog, toCamelCase, toPascalCase, getImportPath, singleQuote, codeToString, quoteObjectKey, addCode, columnDefaultArgumentToCode, deepCompare } from 'orchid-core';
-import { columnsShapeToCode, ColumnType, primaryKeyToCode, indexToCode, constraintToCode, columnIndexesToCode, columnForeignKeysToCode, columnCheckToCode, identityToCode, Db } from 'pqb';
-import { pluralize } from 'inflection';
-
-class FileChanges {
-  constructor(content) {
-    this.content = content;
-    this.ranges = [];
-  }
-  add(at, text, end = at) {
-    if (this.ranges.length === 0) {
-      this.ranges.push([0, at], text, [end, this.content.length]);
-    } else {
-      const last = this.ranges[this.ranges.length - 1];
-      last[1] = at;
-      this.ranges.push(text, [end, this.content.length]);
-    }
-  }
-  replace(from, to, text) {
-    this.add(from, text, to);
-  }
-  remove(from, to) {
-    if (this.ranges.length === 0) {
-      this.ranges.push([0, from], [to, this.content.length]);
-    } else {
-      const last = this.ranges[this.ranges.length - 1];
-      last[1] = from;
-      this.ranges.push([to, this.content.length]);
-    }
-  }
-  apply() {
-    return this.ranges.length ? this.ranges.map(
-      (item) => typeof item === "string" ? item : this.content.slice(item[0], item[1])
-    ).join("") : this.content;
-  }
-}
-
-const { createSourceFile, ScriptTarget, SyntaxKind } = typescript;
-const iterate = (kind) => {
-  return function* (statements) {
-    for (const node of statements) {
-      if (node.kind === kind) {
-        yield node;
-      }
-    }
-  };
-};
-const isNode = (kind) => {
-  return (node) => {
-    return (node == null ? void 0 : node.kind) === kind;
-  };
-};
-const ts = {
-  getStatements(content) {
-    const { statements } = createSourceFile(
-      "file.ts",
-      content,
-      ScriptTarget.Latest,
-      true
-    );
-    return statements;
-  },
-  is: {
-    call: isNode(SyntaxKind.CallExpression),
-    objectLiteral: isNode(
-      SyntaxKind.ObjectLiteralExpression
-    ),
-    propertyAssignment: isNode(
-      SyntaxKind.PropertyAssignment
-    ),
-    shorthandPropertyAssignment: isNode(
-      SyntaxKind.ShorthandPropertyAssignment
-    ),
-    identifier: isNode(SyntaxKind.Identifier),
-    stringLiteral: isNode(SyntaxKind.StringLiteral),
-    arrayLiteral: isNode(
-      SyntaxKind.ArrayLiteralExpression
-    ),
-    numericLiteral: isNode(SyntaxKind.NumericLiteral),
-    computedPropertyName: isNode(
-      SyntaxKind.ComputedPropertyName
-    ),
-    privateIdentifier: isNode(SyntaxKind.PrivateIdentifier),
-    this: isNode(SyntaxKind.ThisKeyword),
-    propertyAccess: isNode(
-      SyntaxKind.PropertyAccessExpression
-    ),
-    arrowFunction: isNode(SyntaxKind.ArrowFunction),
-    parenthesizedExpression: isNode(
-      SyntaxKind.ParenthesizedExpression
-    ),
-    spreadAssignment: isNode(SyntaxKind.SpreadAssignment)
-  },
-  import: {
-    iterate: iterate(SyntaxKind.ImportDeclaration),
-    *iterateWithSource(statements, path) {
-      for (const node of ts.import.iterate(statements)) {
-        if (ts.import.getSource(node) !== path)
-          continue;
-        yield node;
-      }
-    },
-    getSource(node) {
-      return node.moduleSpecifier.getText().slice(1, -1);
-    },
-    getEndPos(statements) {
-      let end = 0;
-      for (const node of ts.import.iterate(statements)) {
-        end = node.end;
-      }
-      return end;
-    },
-    getStatementsImportedName(statements, path, key) {
-      for (const node of ts.import.iterateWithSource(statements, path)) {
-        const name = ts.import.getImportName(node, key);
-        if (name)
-          return name;
-      }
-      return;
-    },
-    getImportName(node, key) {
-      var _a, _b;
-      if (!node.importClause)
-        return;
-      const elements = (_a = node.importClause.namedBindings) == null ? void 0 : _a.elements;
-      if (!elements)
-        return;
-      for (const element of elements) {
-        if (((_b = element.propertyName) == null ? void 0 : _b.escapedText) === key || element.name.escapedText === key) {
-          return element.name.escapedText.toString();
-        }
-      }
-      return;
-    }
-  },
-  variable: {
-    iterate: iterate(SyntaxKind.VariableStatement),
-    *iterateDeclarations(statements) {
-      for (const node of ts.variable.iterate(statements)) {
-        for (const dec of node.declarationList.declarations) {
-          yield dec;
-        }
-      }
-    }
-  },
-  class: {
-    iterate: iterate(SyntaxKind.ClassDeclaration)
-  },
-  prop: {
-    getName({ name }) {
-      if (ts.is.identifier(name)) {
-        return name.escapedText;
-      } else if (name && "text" in name) {
-        return name.text;
-      } else {
-        return name == null ? void 0 : name.getText();
-      }
-    },
-    getValue(prop) {
-      if (ts.is.propertyAssignment(prop)) {
-        return prop.initializer.getText();
-      } else if (ts.is.shorthandPropertyAssignment(prop)) {
-        return prop.name.escapedText.toString();
-      } else {
-        return;
-      }
-    }
-  },
-  spaces: {
-    getAtLine(content, pos) {
-      var _a;
-      const lines = content.slice(0, pos).split("\n");
-      const last = lines[lines.length - 1];
-      return ((_a = last.match(/^\s+/)) == null ? void 0 : _a[0]) || "";
-    }
-  }
-};
-
-const libraryName = "orchid-orm";
-const importKey = "orchidORM";
-const newFile = (options) => `import { orchidORM } from 'orchid-orm';
-
-export const db = orchidORM(
-  {
-    ${optionsToString(options)}
-  },
-  {
-  }
-);
-`;
-const optionsToString = (options) => {
-  const lines = [];
-  for (const key in options) {
-    const value = options[key];
-    if (typeof value !== "object" && typeof value !== "function") {
-      lines.push(
-        `${key}: ${typeof value === "string" ? singleQuote(value) : value},`
-      );
-    }
-  }
-  return lines.join("\n    ");
-};
-const updateMainFile = async (filePath, tablePath, ast, options, logger) => {
-  const result = await fs.readFile(filePath, "utf-8").then(
-    (content2) => ({ error: void 0, content: content2 }),
-    (error) => {
-      return { error, content: void 0 };
-    }
-  );
-  if (result.error && result.error.code !== "ENOENT")
-    throw result.error;
-  const content = result.content || newFile(options);
-  const statements = ts.getStatements(content);
-  const importName = ts.import.getStatementsImportedName(
-    statements,
-    libraryName,
-    importKey
-  );
-  if (!importName) {
-    throw new AppCodeUpdaterError(
-      `Main file does not contain import of orchid-orm`
-    );
-  }
-  const object = getTablesListObject(importName, statements);
-  if (!object) {
-    throw new Error("List of tables is not found in main file");
-  }
-  const spaces = ts.spaces.getAtLine(content, object.end);
-  const context = {
-    filePath,
-    tablePath,
-    statements,
-    object,
-    content,
-    spaces
-  };
-  let write;
-  if (ast.type === "table") {
-    if (ast.action === "create") {
-      write = createTable$1(context, ast);
-    } else {
-      write = dropTable(context, ast);
-    }
-  }
-  if (write) {
-    if (result.error) {
-      await fs.mkdir(path__default.dirname(filePath), { recursive: true });
-    }
-    await fs.writeFile(filePath, write);
-    logger == null ? void 0 : logger.log(
-      `${result.content ? "Updated" : "Created"} ${pathToLog(filePath)}`
-    );
-  }
-};
-const createTable$1 = ({ filePath, tablePath, statements, object, content, spaces }, ast) => {
-  const key = toCamelCase(ast.name);
-  const value = `${toPascalCase(ast.name)}Table`;
-  const changes = new FileChanges(content);
-  const importPath = getImportPath(filePath, tablePath(toCamelCase(ast.name)));
-  const existing = Array.from(
-    ts.import.iterateWithSource(statements, importPath)
-  );
-  if (existing.length)
-    return;
-  for (const prop of object.properties) {
-    if (key === ts.prop.getName(prop)) {
-      return;
-    }
-  }
-  const importPos = ts.import.getEndPos(statements);
-  changes.add(
-    importPos,
-    `${importPos === 0 ? "" : "\n"}import { ${value} } from '${importPath}';`
-  );
-  let insert = `
-${spaces}  ${key}: ${value},`;
-  if (object.properties.length && !object.properties.hasTrailingComma) {
-    insert = `,${insert}`;
-  }
-  if (!content.slice(object.properties.end, object.end).includes("\n")) {
-    insert += `
-${spaces}`;
-  }
-  changes.add(object.properties.end, insert);
-  return changes.apply();
-};
-const dropTable = ({ filePath, tablePath, statements, object, content }, ast) => {
-  const changes = new FileChanges(content);
-  const importPath = getImportPath(filePath, tablePath(toCamelCase(ast.name)));
-  const tableClassName = `${toPascalCase(ast.name)}Table`;
-  const importNames = [];
-  for (const node of ts.import.iterateWithSource(statements, importPath)) {
-    changes.remove(node.pos, node.end);
-    const name = ts.import.getImportName(node, tableClassName);
-    if (name && !importNames.includes(name)) {
-      importNames.push(name);
-    }
-  }
-  for (const prop of object.properties) {
-    const name = ts.prop.getValue(prop);
-    if (!name || !importNames.includes(name))
-      continue;
-    let { end } = prop;
-    if (content[end] === ",")
-      end++;
-    changes.remove(prop.pos, end);
-  }
-  return changes.apply();
-};
-const getTablesListObject = (importName, statements) => {
-  for (const node of ts.variable.iterateDeclarations(statements)) {
-    const call = node.initializer;
-    if (!ts.is.call(call))
-      continue;
-    if (call.expression.getText() !== importName)
-      continue;
-    if (call.arguments.length !== 2) {
-      throw new Error(
-        "Invalid number of arguments when initializing orchid orm"
-      );
-    }
-    const object = call.arguments[1];
-    if (!ts.is.objectLiteral(object)) {
-      throw new Error("Second argument of orchidORM must be an object literal");
-    }
-    return object;
-  }
-  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;
-var __objRest$3 = (source, exclude) => {
-  var target = {};
-  for (var prop in source)
-    if (__hasOwnProp$4.call(source, prop) && exclude.indexOf(prop) < 0)
-      target[prop] = source[prop];
-  if (source != null && __getOwnPropSymbols$4)
-    for (var prop of __getOwnPropSymbols$4(source)) {
-      if (exclude.indexOf(prop) < 0 && __propIsEnum$4.call(source, prop))
-        target[prop] = source[prop];
-    }
-  return target;
-};
-const createTable = async (_a) => {
-  var _b = _a, {
-    ast,
-    logger,
-    getTable,
-    relations,
-    tables,
-    delayed
-  } = _b, params = __objRest$3(_b, [
-    "ast",
-    "logger",
-    "getTable",
-    "relations",
-    "tables",
-    "delayed"
-  ]);
-  const key = toCamelCase(ast.name);
-  const tablePath = params.tablePath(key);
-  const baseTablePath = getImportPath(
-    tablePath,
-    params.baseTable.getFilePath()
-  );
-  const className = `${toPascalCase(ast.name)}Table`;
-  tables[ast.name] = {
-    key,
-    name: className,
-    path: tablePath
-  };
-  const imports = {
-    [baseTablePath]: params.baseTable.exportAs
-  };
-  const props = [];
-  if (ast.schema) {
-    props.push(`schema = ${singleQuote(ast.schema)};`);
-  }
-  props.push(`readonly table = ${singleQuote(ast.name)};`);
-  if (ast.noPrimaryKey === "ignore") {
-    props.push("noPrimaryKey = true;");
-  }
-  props.push(
-    "columns = this.setColumns((t) => ({",
-    columnsShapeToCode(ast.shape, ast, "t"),
-    "}));"
-  );
-  const importsCode = importsToCode(imports);
-  const code = [
-    `export class ${className} extends ${params.baseTable.exportAs} {`,
-    props,
-    "}\n"
-  ];
-  await fs.mkdir(path__default.dirname(tablePath), { recursive: true });
-  try {
-    const content = importsCode + "\n\n" + codeToString(code, "", "  ");
-    await fs.writeFile(tablePath, content, { flag: "wx" });
-    delayed.push(async () => {
-      const imports2 = {};
-      const relCode = await getRelations(
-        ast,
-        getTable,
-        tablePath,
-        imports2,
-        relations,
-        ast.name
-      );
-      if (relCode) {
-        const code2 = codeToString(relCode, "  ", "  ");
-        const updated = content.slice(0, importsCode.length) + `
-${importsToCode(imports2)}` + content.slice(importsCode.length, -2) + "  \n" + code2 + "\n" + content.slice(-2);
-        await fs.writeFile(tablePath, updated);
-      }
-      logger == null ? void 0 : logger.log(`Created ${pathToLog(tablePath)}`);
-    });
-  } catch (err) {
-    if (err.code !== "EEXIST") {
-      throw err;
-    }
-  }
-};
-function importsToCode(imports) {
-  return Object.entries(imports).map(([from, name]) => `import { ${name} } from '${from}';`).join("\n");
-}
-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}, {`,
-      [
-        `columns: [${columns.map(singleQuote).join(", ")}],`,
-        `references: [${foreignColumns.map(singleQuote).join(", ")}],`
-      ],
-      "}),"
-    );
-    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;
-var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
-var __propIsEnum$3 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$2 = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp$3.call(b, prop))
-      __defNormalProp$2(a, prop, b[prop]);
-  if (__getOwnPropSymbols$3)
-    for (var prop of __getOwnPropSymbols$3(b)) {
-      if (__propIsEnum$3.call(b, prop))
-        __defNormalProp$2(a, prop, b[prop]);
-    }
-  return a;
-};
-var __objRest$2 = (source, exclude) => {
-  var target = {};
-  for (var prop in source)
-    if (__hasOwnProp$3.call(source, prop) && exclude.indexOf(prop) < 0)
-      target[prop] = source[prop];
-  if (source != null && __getOwnPropSymbols$3)
-    for (var prop of __getOwnPropSymbols$3(source)) {
-      if (exclude.indexOf(prop) < 0 && __propIsEnum$3.call(source, prop))
-        target[prop] = source[prop];
-    }
-  return target;
-};
-const changeTable = async (_a) => {
-  var _b = _a, {
-    ast,
-    logger
-  } = _b, params = __objRest$2(_b, [
-    "ast",
-    "logger"
-  ]);
-  const tablePath = params.tablePath(toCamelCase(ast.name));
-  const content = await fs.readFile(tablePath, "utf-8").catch(() => void 0);
-  if (!content)
-    return;
-  const changes = new FileChanges(content);
-  const statements = ts.getStatements(content);
-  const className = toPascalCase(ast.name) + "Table";
-  for (const { t, object } of iterateColumnsShapes(statements, className)) {
-    const context = makeChangeContext(changes, ast, content, object, t);
-    prependSpaces(context);
-    applySchemaChanges(context);
-    appendTrailingComma(context);
-    addColumns(context);
-    addTableData(context);
-  }
-  await fs.writeFile(tablePath, changes.apply());
-  logger == null ? void 0 : logger.log(`Updated ${pathToLog(tablePath)}`);
-};
-function* iterateColumnsShapes(statements, className) {
-  var _a, _b;
-  for (const node of ts.class.iterate(statements)) {
-    if (((_a = node.name) == null ? void 0 : _a.escapedText) !== className)
-      continue;
-    for (const member of node.members) {
-      const name = ts.prop.getName(member);
-      const { initializer: call } = member;
-      if (name !== "columns" || !call || !ts.is.call(call))
-        continue;
-      const { expression } = call;
-      if (!ts.is.propertyAccess(expression) || !ts.is.this(expression.expression) || expression.name.escapedText !== "setColumns")
-        continue;
-      const [arg] = call.arguments;
-      if (!ts.is.arrowFunction(arg))
-        continue;
-      const { parameters, body } = arg;
-      const param = (_b = parameters[0]) == null ? void 0 : _b.name;
-      if (!ts.is.identifier(param) || !ts.is.parenthesizedExpression(body))
-        continue;
-      const { expression: object } = body;
-      if (!ts.is.objectLiteral(object))
-        continue;
-      yield { t: param.escapedText.toString(), object };
-    }
-  }
-}
-const makeChangeContext = (changes, ast, content, object, t) => {
-  const add = {};
-  const drop = {};
-  const change = {};
-  const { properties: props } = object;
-  const existingColumns = getExistingColumns(props);
-  for (const key in ast.shape) {
-    const item = ast.shape[key];
-    if (item.type === "add" && !existingColumns[key]) {
-      add[key] = item.item;
-    }
-    if (!existingColumns[key])
-      continue;
-    if (item.type === "drop" && existingColumns[key]) {
-      drop[key] = true;
-    } else if (item.type === "change" && existingColumns[key]) {
-      change[key] = item;
-    }
-  }
-  const spaces = ts.spaces.getAtLine(content, object.end);
-  const shape = { add, drop, change };
-  return {
-    changes,
-    props,
-    shape,
-    spaces,
-    t,
-    object,
-    add: ast.add,
-    drop: ast.drop
-  };
-};
-const getExistingColumns = (props) => {
-  const existingColumns = {};
-  props.map((prop) => ts.is.propertyAssignment(prop) && ts.prop.getName(prop)).filter((name) => !!name).forEach((name) => existingColumns[name] = true);
-  for (const prop of props) {
-    if (!ts.is.propertyAssignment(prop))
-      continue;
-    const name = ts.prop.getName(prop);
-    if (name)
-      existingColumns[name] = true;
-  }
-  return existingColumns;
-};
-const prependSpaces = ({
-  props,
-  shape: { add },
-  changes,
-  spaces
-}) => {
-  if (Object.keys(add).length && props.pos === props.end) {
-    changes.add(props.pos, `
-${spaces}`);
-  }
-};
-const applySchemaChanges = (context) => {
-  const {
-    props,
-    shape: { drop: dropColumns, change: changeColumns },
-    add,
-    drop
-  } = context;
-  props.forEach((prop, i) => {
-    if (ts.is.spreadAssignment(prop)) {
-      const call = prop.expression;
-      if (!ts.is.call(call))
-        return;
-      const access = call.expression;
-      if (!ts.is.propertyAccess(access))
-        return;
-      const name = access.name.escapedText.toString();
-      if (name === "primaryKey") {
-        if (drop.primaryKey || add.primaryKey) {
-          removeProp(context, prop, i);
-        }
-      } else if (name === "index") {
-        dropMatchingIndexes(context, prop, i, call, drop.indexes);
-      } else if (name === "foreignKey") {
-        dropMatchingForeignKey(context, prop, i, call, drop.constraints);
-      } else if (name === "check") {
-        dropMatchingCheck(context, prop, i, call, drop.constraints);
-      } else if (name === "constraint") {
-        dropMatchingConstraint(context, prop, i, call, drop.constraints);
-      }
-    } else if (ts.is.propertyAssignment(prop)) {
-      const name = ts.prop.getName(prop);
-      if (!name)
-        return;
-      if (dropColumns[name]) {
-        removeProp(context, prop, i);
-      } else {
-        const changeItem = changeColumns[name];
-        if (changeItem) {
-          changeColumn(context, changeItem, prop);
-        }
-      }
-    }
-  });
-};
-const removeProp = ({ props, changes }, prop, i) => {
-  var _a;
-  const end = ((_a = props[i + 1]) == null ? void 0 : _a.pos) || props.end;
-  changes.remove(prop.pos, end);
-};
-const changeColumn = ({ changes, t, spaces }, changeItem, prop) => {
-  const { from, to } = changeItem;
-  if ((from.type !== to.type || !!from.identity !== !!to.identity) && to.column) {
-    changes.replace(
-      prop.initializer.pos,
-      prop.end,
-      ` ${codeToString(to.column.toCode(t), spaces + "  ", "  ").trim()}`
-    );
-    return;
-  }
-  const items = [];
-  let chain = prop.initializer;
-  while (ts.is.call(chain) && ts.is.propertyAccess(chain.expression)) {
-    items.push(chain);
-    chain = chain.expression.expression;
-  }
-  const propsToChange = {};
-  for (const key in from) {
-    if (to[key] !== from[key]) {
-      propsToChange[key] = true;
-    }
-  }
-  for (const key in to) {
-    if (to[key] !== from[key]) {
-      propsToChange[key] = true;
-    }
-  }
-  const changedProps = {};
-  const replaced = {};
-  for (const item of items.reverse()) {
-    if (!ts.is.propertyAccess(item.expression))
-      continue;
-    const { name } = item.expression;
-    let key = name.escapedText.toString();
-    if (key === "index")
-      key = "indexes";
-    else if (key === "foreignKey")
-      key = "foreignKeys";
-    if (!propsToChange[key])
-      continue;
-    let remove = true;
-    if (!replaced[key]) {
-      let code = getColumnMethodArgs(t, to, key, to.type);
-      if (!code && key === "identity" && to.type) {
-        code = [`.${to.type}()`];
-      }
-      if (code) {
-        changes.replace(
-          item.expression.expression.end,
-          item.end,
-          codeToString(code, spaces + "  ", "  ").trim()
-        );
-        replaced[key] = true;
-        remove = false;
-      }
-    }
-    if (remove) {
-      changes.remove(item.expression.expression.end, item.end);
-    }
-    changedProps[key] = true;
-  }
-  let append = "";
-  for (const key in propsToChange) {
-    if (changedProps[key])
-      continue;
-    const code = getColumnMethodArgs(t, to, key);
-    if (code) {
-      append += codeToString(code, spaces + "  ", "  ").trim();
-    }
-  }
-  if (append) {
-    changes.add(prop.end, append);
-  }
-};
-const appendTrailingComma = ({ props, changes }) => {
-  if (!props.hasTrailingComma) {
-    const last = props[props.length - 1];
-    if (last) {
-      changes.add(last.end, ",");
-    }
-  }
-};
-const addColumns = ({
-  shape: { add },
-  changes,
-  object,
-  t,
-  spaces
-}) => {
-  const end = object.end - 1;
-  for (const key in add) {
-    const code = codeToString(add[key].toCode(t), spaces + "  ", "  ");
-    changes.add(end, `  ${quoteObjectKey(key)}: ${code.trim()},
-${spaces}`);
-  }
-};
-const addTableData = ({ add, changes, object, t, spaces }) => {
-  const end = object.end - 1;
-  if (add.primaryKey) {
-    const code = codeToString(
-      primaryKeyToCode(add.primaryKey, t),
-      spaces,
-      "  "
-    );
-    changes.add(end, `  ${code.trim()}
-${spaces}`);
-  }
-  if (add.indexes) {
-    for (const item of add.indexes) {
-      const code = codeToString(indexToCode(item, t), spaces + "  ", "  ");
-      changes.add(end, `  ${code.trim()}
-${spaces}`);
-    }
-  }
-  if (add.constraints) {
-    for (const item of add.constraints) {
-      const code = codeToString(constraintToCode(item, t), spaces + "  ", "  ");
-      changes.add(end, `  ${code.trim()}
-${spaces}`);
-    }
-  }
-};
-const getColumnMethodArgs = (t, to, key, dataType) => {
-  const value = to[key];
-  if (!value)
-    return;
-  if (key === "indexes") {
-    return columnIndexesToCode(
-      value
-    );
-  }
-  if (key === "foreignKeys") {
-    return columnForeignKeysToCode(value);
-  }
-  if (key === "check") {
-    return [columnCheckToCode(t, value)];
-  }
-  if (key === "identity") {
-    const code2 = identityToCode(value, dataType);
-    code2[0] = `.${code2[0]}`;
-    return code2;
-  }
-  const code = [`.${key}(`];
-  if (key === "collate" || key === "compression") {
-    addCode(code, singleQuote(value));
-  } else if (key === "default") {
-    addCode(code, columnDefaultArgumentToCode(t, value));
-  } else if (key !== "nullable" && key !== "primaryKey") {
-    return;
-  }
-  addCode(code, ")");
-  return code;
-};
-const dropMatchingIndexes = (context, prop, i, call, items) => {
-  if (!(items == null ? void 0 : items.length))
-    return;
-  const [columnsNode, optionsNode] = call.arguments;
-  const columns = [];
-  if (ts.is.stringLiteral(columnsNode)) {
-    columns.push({ column: columnsNode.text });
-  } else if (ts.is.arrayLiteral(columnsNode)) {
-    for (const node of columnsNode.elements) {
-      if (ts.is.stringLiteral(node)) {
-        columns.push({ column: node.text });
-      } else if (ts.is.objectLiteral(node)) {
-        const object = collectObjectFromCode(node);
-        if (!object)
-          return;
-        columns.push(object);
-      }
-    }
-  } else {
-    return;
-  }
-  const options = ts.is.objectLiteral(optionsNode) && collectObjectFromCode(optionsNode) || {};
-  for (const item of items) {
-    if (deepCompare(columns, item.columns) && deepCompare(options, item.options)) {
-      removeProp(context, prop, i);
-    }
-  }
-};
-const dropMatchingForeignKey = (context, prop, i, call, items) => {
-  if (!(items == null ? void 0 : items.length))
-    return;
-  const existing = parseReferencesArgs(context, call.arguments);
-  if (!existing)
-    return;
-  for (const item of items) {
-    if (compareReferences(existing, item.references))
-      removeProp(context, prop, i);
-  }
-};
-const parseReferencesArgs = (context, args) => {
-  const columns = collectStringArrayFromCode(args[0]);
-  if (!columns)
-    return;
-  const fnOrTableNode = args[1];
-  let fnOrTable;
-  if (ts.is.stringLiteral(fnOrTableNode)) {
-    fnOrTable = fnOrTableNode.text;
-  } else if (ts.is.arrowFunction(fnOrTableNode)) {
-    fnOrTable = context.changes.content.slice(fnOrTableNode.pos, fnOrTableNode.end).replaceAll(/\s/g, "");
-  } else {
-    return;
-  }
-  const foreignColumns = collectStringArrayFromCode(args[2]);
-  if (!foreignColumns)
-    return;
-  const options = ts.is.objectLiteral(args[3]) && collectObjectFromCode(args[3]) || {};
-  return { columns, fnOrTable, foreignColumns, options };
-};
-const compareReferences = (existing, item) => {
-  if (!item)
-    return;
-  const itemOptions = item.options ? __spreadValues$2({}, item.options) : void 0;
-  if (itemOptions) {
-    delete itemOptions.dropMode;
-  }
-  return deepCompare(existing == null ? void 0 : existing.columns, item == null ? void 0 : item.columns) && deepCompare(existing == null ? void 0 : existing.fnOrTable, item == null ? void 0 : item.fnOrTable.toString()) && deepCompare(existing == null ? void 0 : existing.foreignColumns, item == null ? void 0 : item.foreignColumns) && deepCompare(existing == null ? void 0 : existing.options, itemOptions);
-};
-const dropMatchingCheck = (context, prop, i, call, items) => {
-  if (!(items == null ? void 0 : items.length))
-    return;
-  const sql = parseCheckArg(context, call.arguments[0]);
-  for (const item of items) {
-    const { check } = item;
-    if (!check)
-      continue;
-    if (check._sql === sql) {
-      removeProp(context, prop, i);
-    }
-  }
-};
-const parseCheckArg = (context, arg) => {
-  if (!arg || !ts.is.call(arg))
-    return;
-  const { expression } = arg;
-  if (!ts.is.propertyAccess(expression) || !ts.is.identifier(expression.expression) || expression.expression.escapedText !== context.t || expression.name.escapedText !== "sql")
-    return;
-  const [obj] = arg.arguments;
-  if (!obj || !ts.is.objectLiteral(obj))
-    return;
-  for (const prop of obj.properties) {
-    if (!ts.is.propertyAssignment(prop))
-      continue;
-    const name = ts.prop.getName(prop);
-    if (name !== "raw")
-      continue;
-    const init = prop.initializer;
-    if (!ts.is.stringLiteral(init) || !("text" in init))
-      continue;
-    return init.text;
-  }
-  return;
-};
-const dropMatchingConstraint = (context, prop, i, call, items) => {
-  var _a;
-  if (!(items == null ? void 0 : items.length))
-    return;
-  const {
-    arguments: [arg]
-  } = call;
-  if (!arg || !ts.is.objectLiteral(arg))
-    return;
-  const existing = {};
-  for (const prop2 of arg.properties) {
-    if (!ts.is.propertyAssignment(prop2))
-      return;
-    const name = ts.prop.getName(prop2);
-    if (!name)
-      return;
-    const init = prop2.initializer;
-    if (name === "name") {
-      if (!ts.is.stringLiteral(init))
-        return;
-      existing.name = init.text;
-    } else if (name === "references") {
-      if (!ts.is.arrayLiteral(init))
-        return;
-      const refs = parseReferencesArgs(context, init.elements);
-      if (!refs)
-        return;
-      existing.references = refs;
-    } else if (name === "check") {
-      existing.check = parseCheckArg(context, init);
-    }
-  }
-  for (const item of items) {
-    if (existing.name !== item.name)
-      continue;
-    if (existing.check !== ((_a = item.check) == null ? void 0 : _a._sql))
-      continue;
-    if ((existing.references || item.references) && !compareReferences(existing.references, item.references))
-      continue;
-    removeProp(context, prop, i);
-  }
-};
-const collectStringArrayFromCode = (node) => {
-  if (!ts.is.arrayLiteral(node))
-    return;
-  const result = node.elements.filter(ts.is.stringLiteral).map((item) => item.text);
-  return result.length === node.elements.length ? result : void 0;
-};
-const collectObjectFromCode = (node) => {
-  const object = {};
-  for (const prop of node.properties) {
-    if (!ts.is.propertyAssignment(prop))
-      return;
-    const name = ts.prop.getName(prop);
-    if (!name)
-      return;
-    const init = prop.initializer;
-    if (ts.is.stringLiteral(init)) {
-      object[name] = init.text;
-    } else if (ts.is.numericLiteral(init)) {
-      object[name] = parseFloat(init.text);
-    } else {
-      return;
-    }
-  }
-  return object;
-};
-
-var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
-var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
-var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
-var __objRest$1 = (source, exclude) => {
-  var target = {};
-  for (var prop in source)
-    if (__hasOwnProp$2.call(source, prop) && exclude.indexOf(prop) < 0)
-      target[prop] = source[prop];
-  if (source != null && __getOwnPropSymbols$2)
-    for (var prop of __getOwnPropSymbols$2(source)) {
-      if (exclude.indexOf(prop) < 0 && __propIsEnum$2.call(source, prop))
-        target[prop] = source[prop];
-    }
-  return target;
-};
-const renameTable = async (_a) => {
-  var _b = _a, {
-    ast,
-    logger
-  } = _b, params = __objRest$1(_b, [
-    "ast",
-    "logger"
-  ]);
-  var _a2;
-  const tablePath = params.tablePath(toCamelCase(ast.from));
-  const content = await fs.readFile(tablePath, "utf-8").catch(() => void 0);
-  if (!content)
-    return;
-  const changes = new FileChanges(content);
-  const statements = ts.getStatements(content);
-  const className = toPascalCase(ast.from) + "Table";
-  const changeSchema = ast.fromSchema !== ast.toSchema;
-  for (const node of ts.class.iterate(statements)) {
-    if (((_a2 = node.name) == null ? void 0 : _a2.escapedText) !== className)
-      continue;
-    const addSchema = changeSchema && ast.toSchema && !node.members.some((member) => ts.prop.getName(member) === "schema");
-    if (addSchema && ast.toSchema) {
-      changes.add(
-        node.members.pos,
-        `
-  schema = ${singleQuote(ast.toSchema)};`
-      );
-    }
-    for (const member of node.members) {
-      const name = ts.prop.getName(member);
-      if (name !== "table" && !(changeSchema && name === "schema"))
-        continue;
-      const { initializer: value } = member;
-      if (!value)
-        continue;
-      if (name === "schema") {
-        if (ast.toSchema) {
-          changes.replace(
-            value.pos,
-            value.end,
-            ` ${singleQuote(ast.toSchema)}`
-          );
-        } else {
-          changes.remove(member.pos, member.end);
-        }
-      } else {
-        changes.replace(value.pos, value.end, ` ${singleQuote(ast.to)}`);
-      }
-    }
-  }
-  await fs.writeFile(tablePath, changes.apply());
-  logger == null ? void 0 : logger.log(`Updated ${pathToLog(tablePath)}`);
-};
-
-var __defProp$1 = Object.defineProperty;
-var __defProps$1 = Object.defineProperties;
-var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
-var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
-var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$1 = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp$1.call(b, prop))
-      __defNormalProp$1(a, prop, b[prop]);
-  if (__getOwnPropSymbols$1)
-    for (var prop of __getOwnPropSymbols$1(b)) {
-      if (__propIsEnum$1.call(b, prop))
-        __defNormalProp$1(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
-const updateTableFile = async (params) => {
-  const { ast } = params;
-  if (ast.type === "table" && ast.action === "create") {
-    await createTable(__spreadProps$1(__spreadValues$1({}, params), { ast }));
-  } else if (ast.type === "changeTable") {
-    await changeTable(__spreadProps$1(__spreadValues$1({}, params), { ast }));
-  } else if (ast.type === "renameType" && ast.table) {
-    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
-      });
-    }
-  }
-};
-
-const createBaseTableFile = async ({
-  baseTable,
-  logger
-}) => {
-  const filePath = baseTable.getFilePath();
-  await fs.mkdir(path__default.dirname(filePath), { recursive: true });
-  await fs.writeFile(
-    filePath,
-    `import { createBaseTable } from 'orchid-orm';
-
-export const ${baseTable.exportAs} = createBaseTable();
-`,
-    {
-      flag: "wx"
-    }
-  ).then(() => {
-    logger == null ? void 0 : logger.log(`Created ${pathToLog(filePath)}`);
-  }).catch((err) => {
-    if (err.code === "EEXIST")
-      return;
-    throw err;
-  });
-};
-
-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"];
-  const fk = rel[rel.kind === "hasMany" ? "foreignColumns" : "columns"];
-  code.push(
-    `      columns: [${pk.map(singleQuote).join(", ")}],`,
-    `      references: [${fk.map(singleQuote).join(", ")}],`,
-    "    }),"
-  );
-  return code.join("\n");
-};
-
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __objRest = (source, exclude) => {
-  var target = {};
-  for (var prop in source)
-    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
-      target[prop] = source[prop];
-  if (source != null && __getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(source)) {
-      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
-        target[prop] = source[prop];
-    }
-  return target;
-};
-class AppCodeUpdaterError extends Error {
-}
-const makeGetTable = (path2, ormExportedAs, tables, imp) => {
-  let orm;
-  return async (tableName) => {
-    var _a;
-    if (tables[tableName])
-      return tables[tableName];
-    if (!orm) {
-      const mod = await imp(path2).catch((err) => {
-        if (err.code === "ERR_UNKNOWN_FILE_EXTENSION") {
-          return require(path2);
-        } else {
-          throw err;
-        }
-      });
-      orm = mod[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)
-        continue;
-      const name = table.name;
-      if (!name)
-        continue;
-      const path3 = (_a = table.getFilePath) == null ? void 0 : _a.call(table);
-      if (!path3)
-        continue;
-      return tables[tableName] = {
-        key,
-        name,
-        path: path3
-      };
-    }
-    return;
-  };
-};
-const appCodeUpdater = ({
-  tablePath,
-  ormPath,
-  ormExportedAs = "db"
-}) => ({
-  async process(_a) {
-    var _b = _a, { ast, options, basePath, logger, baseTable } = _b, config = __objRest(_b, ["ast", "options", "basePath", "logger", "baseTable"]);
-    var _a2, _b2;
-    const params = {
-      tablePath(name) {
-        const file = tablePath(name);
-        return resolvePath(basePath, file);
-      },
-      ormPath: resolvePath(basePath, ormPath),
-      ormExportedAs,
-      logger
-    };
-    const cache = config.cache;
-    (_a2 = cache.relations) != null ? _a2 : cache.relations = {};
-    (_b2 = cache.tables) != null ? _b2 : cache.tables = {};
-    const getTable = makeGetTable(
-      params.ormPath,
-      ormExportedAs,
-      cache.tables,
-      config.import
-    );
-    await updateMainFile(
-      params.ormPath,
-      params.tablePath,
-      ast,
-      options,
-      logger
-    );
-    const delayed = [];
-    const promises = [
-      updateTableFile(__spreadProps(__spreadValues({}, params), {
-        ast,
-        baseTable,
-        getTable,
-        relations: cache.relations,
-        tables: cache.tables,
-        delayed
-      }))
-    ];
-    if (!cache.createdBaseTable) {
-      promises.push(
-        createBaseTableFile({ logger: params.logger, baseTable }).then(() => {
-          cache.createdBaseTable = true;
-        })
-      );
-    }
-    await Promise.all(promises);
-    await Promise.all(delayed.map((fn) => fn()));
-  },
-  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 };
-//# sourceMappingURL=index.mjs.map