orchid-orm 1.9.21 → 1.9.23

package/dist/index.mjs

@@ -1,12 +1,7 @@
-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';
+import { columnTypes, getColumnTypes, addQueryOn, VirtualColumn, pushQueryValue, isQueryReturnsAll, getQueryAs, toSqlCacheKey, NotFoundError, relationQueryKey, Adapter, Db, anyShape, getClonedQueryData } from 'pqb';
 export { OrchidOrmError, OrchidOrmInternalError, columnTypes, testTransaction } from 'pqb';
-import { getCallerFilePath, snakeCaseKey, toSnakeCase, pathToLog, toCamelCase, toPascalCase, getImportPath, singleQuote, codeToString, quoteObjectKey, addCode, columnDefaultArgumentToCode, deepCompare } from 'orchid-core';
+import { getCallerFilePath, snakeCaseKey, toSnakeCase } from 'orchid-core';
 import { AsyncLocalStorage } from 'node:async_hooks';
-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,
@@ -258,7 +253,8 @@ const nestedUpdate$3 = ({ query, primaryKey, foreignKey }) => {
         if (id !== null) {
           await query.findBy({ [primaryKey]: id })._update(upsert.update);
         } else {
-          const result = await query.select(primaryKey)._create(upsert.create);
+          const data = typeof upsert.create === "function" ? upsert.create() : upsert.create;
+          const result = await query.select(primaryKey)._create(data);
           ((_a2 = state.updateData) != null ? _a2 : state.updateData = {})[foreignKey] = result[primaryKey];
         }
       });
@@ -336,25 +332,25 @@ const hasRelationHandleUpdate = (q, ctx, set, key, primaryKey, nestedUpdate) =>
   });
 };
 
-var __defProp$7 = Object.defineProperty;
-var __defProps$5 = Object.defineProperties;
-var __getOwnPropDescs$5 = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$9 = Object.getOwnPropertySymbols;
-var __hasOwnProp$9 = Object.prototype.hasOwnProperty;
-var __propIsEnum$9 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$7 = (a, b) => {
+var __defProp$4 = Object.defineProperty;
+var __defProps$3 = Object.defineProperties;
+var __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$4 = Object.getOwnPropertySymbols;
+var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
+var __propIsEnum$4 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$4 = (a, b) => {
   for (var prop in b || (b = {}))
-    if (__hasOwnProp$9.call(b, prop))
-      __defNormalProp$7(a, prop, b[prop]);
-  if (__getOwnPropSymbols$9)
-    for (var prop of __getOwnPropSymbols$9(b)) {
-      if (__propIsEnum$9.call(b, prop))
-        __defNormalProp$7(a, prop, b[prop]);
+    if (__hasOwnProp$4.call(b, prop))
+      __defNormalProp$4(a, prop, b[prop]);
+  if (__getOwnPropSymbols$4)
+    for (var prop of __getOwnPropSymbols$4(b)) {
+      if (__propIsEnum$4.call(b, prop))
+        __defNormalProp$4(a, prop, b[prop]);
     }
   return a;
 };
-var __spreadProps$5 = (a, b) => __defProps$5(a, __getOwnPropDescs$5(b));
+var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
 class HasOneVirtualColumn extends VirtualColumn {
   constructor(key, state) {
     super();
@@ -487,7 +483,7 @@ const nestedInsert$2 = ({ query, primaryKey, foreignKey }) => {
     );
     if (create.length) {
       await t._count()._createMany(
-        create.map(([selfData, item]) => __spreadValues$7({
+        create.map(([selfData, item]) => __spreadValues$4({
           [foreignKey]: selfData[primaryKey]
         }, "create" in item ? item.create : item.connectOrCreate.create))
       );
@@ -508,7 +504,7 @@ const nestedUpdate$2 = ({ query, primaryKey, foreignKey }) => {
     if (params.create || params.disconnect || params.set) {
       await currentRelationsQuery._update({ [foreignKey]: null });
       if (params.create) {
-        await t._count()._create(__spreadProps$5(__spreadValues$7({}, params.create), {
+        await t._count()._create(__spreadProps$3(__spreadValues$4({}, params.create), {
           [foreignKey]: data[0][primaryKey]
         }));
       }
@@ -523,8 +519,9 @@ const nestedUpdate$2 = ({ query, primaryKey, foreignKey }) => {
       const { update, create } = params.upsert;
       const updatedIds = await currentRelationsQuery._pluck(foreignKey)._update(update);
       if (updatedIds.length < ids.length) {
+        const data2 = typeof create === "function" ? create() : create;
         await t.createMany(
-          ids.filter((id) => !updatedIds.includes(id)).map((id) => __spreadProps$5(__spreadValues$7({}, create), {
+          ids.filter((id) => !updatedIds.includes(id)).map((id) => __spreadProps$3(__spreadValues$4({}, data2), {
             [foreignKey]: id
           }))
         );
@@ -533,25 +530,25 @@ const nestedUpdate$2 = ({ query, primaryKey, foreignKey }) => {
   };
 };
 
-var __defProp$6 = Object.defineProperty;
-var __defProps$4 = Object.defineProperties;
-var __getOwnPropDescs$4 = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$8 = Object.getOwnPropertySymbols;
-var __hasOwnProp$8 = Object.prototype.hasOwnProperty;
-var __propIsEnum$8 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$6 = (a, b) => {
+var __defProp$3 = Object.defineProperty;
+var __defProps$2 = Object.defineProperties;
+var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$3 = Object.getOwnPropertySymbols;
+var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
+var __propIsEnum$3 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$3 = (a, b) => {
   for (var prop in b || (b = {}))
-    if (__hasOwnProp$8.call(b, prop))
-      __defNormalProp$6(a, prop, b[prop]);
-  if (__getOwnPropSymbols$8)
-    for (var prop of __getOwnPropSymbols$8(b)) {
-      if (__propIsEnum$8.call(b, prop))
-        __defNormalProp$6(a, prop, b[prop]);
+    if (__hasOwnProp$3.call(b, prop))
+      __defNormalProp$3(a, prop, b[prop]);
+  if (__getOwnPropSymbols$3)
+    for (var prop of __getOwnPropSymbols$3(b)) {
+      if (__propIsEnum$3.call(b, prop))
+        __defNormalProp$3(a, prop, b[prop]);
     }
   return a;
 };
-var __spreadProps$4 = (a, b) => __defProps$4(a, __getOwnPropDescs$4(b));
+var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
 class HasManyVirtualColumn extends VirtualColumn {
   constructor(key, state) {
     super();
@@ -717,10 +714,10 @@ const nestedInsert$1 = ({ query, primaryKey, foreignKey }) => {
       await t._createMany(
         create.flatMap(([selfData, { create: create2 = [], connectOrCreate: connectOrCreate2 = [] }]) => {
           return [
-            ...create2.map((item) => __spreadValues$6({
+            ...create2.map((item) => __spreadValues$3({
               [foreignKey]: selfData[primaryKey]
             }, item)),
-            ...connectOrCreate2.filter(() => connected[connectedI++] === 0).map((item) => __spreadValues$6({
+            ...connectOrCreate2.filter(() => connected[connectedI++] === 0).map((item) => __spreadValues$3({
               [foreignKey]: selfData[primaryKey]
             }, item.create))
           ];
@@ -739,7 +736,7 @@ const nestedUpdate$1 = ({ query, primaryKey, foreignKey }) => {
     const t = query.clone();
     if (params.create) {
       await t._count()._createMany(
-        params.create.map((create) => __spreadProps$4(__spreadValues$6({}, create), {
+        params.create.map((create) => __spreadProps$2(__spreadValues$3({}, create), {
           [foreignKey]: data[0][primaryKey]
         }))
       );
@@ -782,25 +779,25 @@ const nestedUpdate$1 = ({ query, primaryKey, foreignKey }) => {
   };
 };
 
-var __defProp$5 = Object.defineProperty;
-var __defProps$3 = Object.defineProperties;
-var __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$7 = Object.getOwnPropertySymbols;
-var __hasOwnProp$7 = Object.prototype.hasOwnProperty;
-var __propIsEnum$7 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$5 = (a, b) => {
+var __defProp$2 = Object.defineProperty;
+var __defProps$1 = Object.defineProperties;
+var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
+var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
+var __propIsEnum$2 = 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$7.call(b, prop))
-      __defNormalProp$5(a, prop, b[prop]);
-  if (__getOwnPropSymbols$7)
-    for (var prop of __getOwnPropSymbols$7(b)) {
-      if (__propIsEnum$7.call(b, prop))
-        __defNormalProp$5(a, prop, b[prop]);
+    if (__hasOwnProp$2.call(b, prop))
+      __defNormalProp$2(a, prop, b[prop]);
+  if (__getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(b)) {
+      if (__propIsEnum$2.call(b, prop))
+        __defNormalProp$2(a, prop, b[prop]);
     }
   return a;
 };
-var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
+var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
 class HasAndBelongsToManyVirtualColumn extends VirtualColumn {
   constructor(key, state) {
     super();
@@ -835,7 +832,7 @@ const removeColumnName = (column) => {
   if (!column.data.name)
     return column;
   const cloned = Object.create(column);
-  cloned.data = __spreadProps$3(__spreadValues$5({}, column.data), { name: void 0 });
+  cloned.data = __spreadProps$1(__spreadValues$2({}, column.data), { name: void 0 });
   return cloned;
 };
 const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query) => {
@@ -856,7 +853,7 @@ const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query)
     [fk]: removeColumnName(table.shape[pk]),
     [afk]: removeColumnName(query.shape[apk])
   };
-  baseQuery.query = __spreadProps$3(__spreadValues$5({}, baseQuery.query), {
+  baseQuery.query = __spreadProps$1(__spreadValues$2({}, baseQuery.query), {
     shape: baseQuery.shape
   });
   const subQuery = Object.create(baseQuery);
@@ -889,7 +886,7 @@ const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query)
         subQuery,
         (q) => q._on(associationForeignKeyFull, `${getQueryAs(toQuery)}.${apk}`)._on(foreignKeyFull, `${getQueryAs(fromQuery)}.${pk}`)
       );
-      join.query.joinedShapes = __spreadProps$3(__spreadValues$5({}, join.query.joinedShapes), {
+      join.query.joinedShapes = __spreadProps$1(__spreadValues$2({}, join.query.joinedShapes), {
         [fromQuery.query.as || fromQuery.table]: fromQuery.query.shape
       });
       return join;
@@ -1245,6 +1242,16 @@ const applyRelation = (qb, { relationName, relation, dbTable, otherDbTable }, de
   }
   makeRelationQuery(dbTable, relationName, data, query);
   baseQuery.joinQuery = data.joinQuery;
+  const { join: originalJoin } = baseQuery;
+  baseQuery.join = function(...args) {
+    if (args.length) {
+      return originalJoin.apply(this, args);
+    } else {
+      const q = this.clone();
+      q.query.innerJoinLateral = true;
+      return q;
+    }
+  };
   dbTable.relations[relationName] = {
     type,
     key: relationName,
@@ -1295,33 +1302,33 @@ function transaction(fnOrOptions, fn) {
   );
 }
 
-var __defProp$4 = Object.defineProperty;
-var __defProps$2 = Object.defineProperties;
-var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$6 = Object.getOwnPropertySymbols;
-var __hasOwnProp$6 = Object.prototype.hasOwnProperty;
-var __propIsEnum$6 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$4 = (a, b) => {
+var __defProp$1 = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = 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$6.call(b, prop))
-      __defNormalProp$4(a, prop, b[prop]);
-  if (__getOwnPropSymbols$6)
-    for (var prop of __getOwnPropSymbols$6(b)) {
-      if (__propIsEnum$6.call(b, prop))
-        __defNormalProp$4(a, prop, b[prop]);
+    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$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
-var __objRest$3 = (source, exclude) => {
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
   var target = {};
   for (var prop in source)
-    if (__hasOwnProp$6.call(source, prop) && exclude.indexOf(prop) < 0)
+    if (__hasOwnProp$1.call(source, prop) && exclude.indexOf(prop) < 0)
       target[prop] = source[prop];
-  if (source != null && __getOwnPropSymbols$6)
-    for (var prop of __getOwnPropSymbols$6(source)) {
-      if (exclude.indexOf(prop) < 0 && __propIsEnum$6.call(source, prop))
+  if (source != null && __getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$1.call(source, prop))
         target[prop] = source[prop];
     }
   return target;
@@ -1332,7 +1339,7 @@ const orchidORM = (_a, tables) => {
     logger,
     autoPreparedStatements,
     noPrimaryKey = "error"
-  } = _b, options = __objRest$3(_b, [
+  } = _b, options = __objRest(_b, [
     "log",
     "logger",
     "autoPreparedStatements",
@@ -1379,7 +1386,7 @@ const orchidORM = (_a, tables) => {
     }
     const table = new tables[key]();
     tableInstances[key] = table;
-    const options2 = __spreadProps$2(__spreadValues$4({}, commonOptions), {
+    const options2 = __spreadProps(__spreadValues$1({}, commonOptions), {
       schema: table.schema
     });
     if (table.noPrimaryKey)
@@ -1404,24 +1411,24 @@ const orchidORM = (_a, tables) => {
   return result;
 };
 
-var __defProp$3 = Object.defineProperty;
-var __getOwnPropSymbols$5 = Object.getOwnPropertySymbols;
-var __hasOwnProp$5 = Object.prototype.hasOwnProperty;
-var __propIsEnum$5 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$3 = (a, b) => {
+var __defProp = Object.defineProperty;
+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$5.call(b, prop))
-      __defNormalProp$3(a, prop, b[prop]);
-  if (__getOwnPropSymbols$5)
-    for (var prop of __getOwnPropSymbols$5(b)) {
-      if (__propIsEnum$5.call(b, prop))
-        __defNormalProp$3(a, prop, b[prop]);
+    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;
 };
 const createRepo = (table, methods) => {
-  const queryMethods = __spreadValues$3(__spreadValues$3(__spreadValues$3(__spreadValues$3({}, methods.queryMethods), methods.queryOneMethods), methods.queryWithWhereMethods), methods.queryOneWithWhereMethods);
+  const queryMethods = __spreadValues(__spreadValues(__spreadValues(__spreadValues({}, methods.queryMethods), methods.queryOneMethods), methods.queryWithWhereMethods), methods.queryOneWithWhereMethods);
   const plainMethods = methods.methods;
   const repo = (q2) => {
     const proto = Object.create(q2.baseQuery);
@@ -1447,1372 +1454,5 @@ const createRepo = (table, methods) => {
   });
 };
 
-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 {
-        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$2 = (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
-  } = _b, params = __objRest$2(_b, [
-    "ast",
-    "logger",
-    "getTable",
-    "relations",
-    "tables"
-  ]);
-  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)};`);
-  }
-  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 relCode = await getRelations(
-    ast,
-    getTable,
-    tablePath,
-    imports,
-    relations,
-    ast.name
-  );
-  if (relCode) {
-    props.push("", ...relCode);
-  }
-  const code = [
-    ...Object.entries(imports).map(
-      ([from, name]) => `import { ${name} } from '${from}';`
-    ),
-    "",
-    `export class ${className} extends ${params.baseTable.name} {`,
-    props,
-    "}\n"
-  ];
-  await fs.mkdir(path__default.dirname(tablePath), { recursive: true });
-  try {
-    await fs.writeFile(tablePath, codeToString(code, "", "  "), { flag: "wx" });
-    logger == null ? void 0 : logger.log(`Created ${pathToLog(tablePath)}`);
-  } catch (err) {
-    if (err.code !== "EEXIST") {
-      throw err;
-    }
-  }
-};
-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;
-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$1 = (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$1(_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.__raw === 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 !== "raw")
-    return;
-  const [sqlArg] = arg.arguments;
-  if (!sqlArg || !ts.is.stringLiteral(sqlArg))
-    return;
-  return sqlArg.text;
-};
-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.__raw))
-      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 = (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(_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 === "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
-      });
-    }
-  }
-};
-
-const createBaseTableFile = async ({
-  baseTable,
-  logger
-}) => {
-  await fs.mkdir(path__default.dirname(baseTable.filePath), { recursive: true });
-  await fs.writeFile(
-    baseTable.filePath,
-    `import { createBaseTable } from 'orchid-orm';
-
-export const ${baseTable.name} = createBaseTable();
-`,
-    {
-      flag: "wx"
-    }
-  ).then(() => {
-    logger == null ? void 0 : logger.log(`Created ${pathToLog(baseTable.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"][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;
-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));
-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,
-  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);
-      },
-      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.ormPath, params.tablePath, ast, options, logger),
-      updateTableFile(__spreadProps(__spreadValues({}, params), {
-        ast,
-        baseTable,
-        getTable,
-        relations: cache.relations,
-        tables: cache.tables
-      }))
-    ];
-    if (!cache.createdBaseTable) {
-      promises.push(
-        createBaseTableFile({ logger: params.logger, baseTable }).then(() => {
-          cache.createdBaseTable = true;
-        })
-      );
-    }
-    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 };
+export { createBaseTable, createRepo, orchidORM };
 //# sourceMappingURL=index.mjs.map