orchid-orm 1.4.19 → 1.4.21

package/dist/index.esm.js

@@ -1,4 +1,8 @@
-import { getColumnTypes, addQueryOn, VirtualColumn, pushQueryValue, isQueryReturnsAll, getQueryAs, toSqlCacheKey, NotFoundError, relationQueryKey, Db, Adapter, anyShape, columnTypes, getClonedQueryData } from 'pqb';
+import { getColumnTypes, addQueryOn, VirtualColumn, pushQueryValue, isQueryReturnsAll, getQueryAs, toSqlCacheKey, NotFoundError, relationQueryKey, Db, Adapter, anyShape, columnTypes, getClonedQueryData, singleQuote, columnsShapeToCode, codeToString, addCode, quoteObjectKey, primaryKeyToCode, indexToCode, foreignKeyToCode, columnDefaultArgumentToCode } from 'pqb';
+import * as path from 'path';
+import path__default from 'path';
+import fs from 'fs/promises';
+import { createSourceFile, ScriptTarget, SyntaxKind } from 'typescript';
 
 const createBaseTable = (options) => {
   return class BaseTable {
@@ -292,25 +296,25 @@ const hasRelationHandleUpdate = (q, ctx, set, key, primaryKey, nestedUpdate) =>
   });
 };
 
-var __defProp$4 = Object.defineProperty;
-var __defProps$2 = Object.defineProperties;
-var __getOwnPropDescs$2 = 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) => {
+var __defProp$6 = Object.defineProperty;
+var __defProps$4 = Object.defineProperties;
+var __getOwnPropDescs$4 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$9 = Object.getOwnPropertySymbols;
+var __hasOwnProp$9 = Object.prototype.hasOwnProperty;
+var __propIsEnum$9 = 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) => {
   for (var prop in b || (b = {}))
-    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]);
+    if (__hasOwnProp$9.call(b, prop))
+      __defNormalProp$6(a, prop, b[prop]);
+  if (__getOwnPropSymbols$9)
+    for (var prop of __getOwnPropSymbols$9(b)) {
+      if (__propIsEnum$9.call(b, prop))
+        __defNormalProp$6(a, prop, b[prop]);
     }
   return a;
 };
-var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
+var __spreadProps$4 = (a, b) => __defProps$4(a, __getOwnPropDescs$4(b));
 class HasOneVirtualColumn extends VirtualColumn {
   constructor(key, state) {
     super();
@@ -443,7 +447,7 @@ const nestedInsert$2 = ({ query, primaryKey, foreignKey }) => {
     );
     if (create.length) {
       await t._count()._createMany(
-        create.map(([selfData, item]) => __spreadValues$4({
+        create.map(([selfData, item]) => __spreadValues$6({
           [foreignKey]: selfData[primaryKey]
         }, "create" in item ? item.create : item.connectOrCreate.create))
       );
@@ -464,7 +468,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$2(__spreadValues$4({}, params.create), {
+        await t._count()._create(__spreadProps$4(__spreadValues$6({}, params.create), {
           [foreignKey]: data[0][primaryKey]
         }));
       }
@@ -480,7 +484,7 @@ const nestedUpdate$2 = ({ query, primaryKey, foreignKey }) => {
       const updatedIds = await currentRelationsQuery._pluck(foreignKey)._update(update);
       if (updatedIds.length < ids.length) {
         await t.createMany(
-          ids.filter((id) => !updatedIds.includes(id)).map((id) => __spreadProps$2(__spreadValues$4({}, create), {
+          ids.filter((id) => !updatedIds.includes(id)).map((id) => __spreadProps$4(__spreadValues$6({}, create), {
             [foreignKey]: id
           }))
         );
@@ -489,25 +493,25 @@ const nestedUpdate$2 = ({ query, primaryKey, foreignKey }) => {
   };
 };
 
-var __defProp$3 = Object.defineProperty;
-var __defProps$1 = Object.defineProperties;
-var __getOwnPropDescs$1 = 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) => {
+var __defProp$5 = Object.defineProperty;
+var __defProps$3 = Object.defineProperties;
+var __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$8 = Object.getOwnPropertySymbols;
+var __hasOwnProp$8 = Object.prototype.hasOwnProperty;
+var __propIsEnum$8 = 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) => {
   for (var prop in b || (b = {}))
-    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]);
+    if (__hasOwnProp$8.call(b, prop))
+      __defNormalProp$5(a, prop, b[prop]);
+  if (__getOwnPropSymbols$8)
+    for (var prop of __getOwnPropSymbols$8(b)) {
+      if (__propIsEnum$8.call(b, prop))
+        __defNormalProp$5(a, prop, b[prop]);
     }
   return a;
 };
-var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
+var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
 class HasManyVirtualColumn extends VirtualColumn {
   constructor(key, state) {
     super();
@@ -673,10 +677,10 @@ const nestedInsert$1 = ({ query, primaryKey, foreignKey }) => {
       await t._createMany(
         create.flatMap(([selfData, { create: create2 = [], connectOrCreate: connectOrCreate2 = [] }]) => {
           return [
-            ...create2.map((item) => __spreadValues$3({
+            ...create2.map((item) => __spreadValues$5({
               [foreignKey]: selfData[primaryKey]
             }, item)),
-            ...connectOrCreate2.filter(() => connected[connectedI++] === 0).map((item) => __spreadValues$3({
+            ...connectOrCreate2.filter(() => connected[connectedI++] === 0).map((item) => __spreadValues$5({
               [foreignKey]: selfData[primaryKey]
             }, item.create))
           ];
@@ -695,7 +699,7 @@ const nestedUpdate$1 = ({ query, primaryKey, foreignKey }) => {
     const t = query.transacting(q);
     if (params.create) {
       await t._count()._createMany(
-        params.create.map((create) => __spreadProps$1(__spreadValues$3({}, create), {
+        params.create.map((create) => __spreadProps$3(__spreadValues$5({}, create), {
           [foreignKey]: data[0][primaryKey]
         }))
       );
@@ -738,19 +742,19 @@ const nestedUpdate$1 = ({ query, primaryKey, foreignKey }) => {
   };
 };
 
-var __defProp$2 = Object.defineProperty;
-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) => {
+var __defProp$4 = Object.defineProperty;
+var __getOwnPropSymbols$7 = Object.getOwnPropertySymbols;
+var __hasOwnProp$7 = Object.prototype.hasOwnProperty;
+var __propIsEnum$7 = 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$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]);
+    if (__hasOwnProp$7.call(b, prop))
+      __defNormalProp$4(a, prop, b[prop]);
+  if (__getOwnPropSymbols$7)
+    for (var prop of __getOwnPropSymbols$7(b)) {
+      if (__propIsEnum$7.call(b, prop))
+        __defNormalProp$4(a, prop, b[prop]);
     }
   return a;
 };
@@ -803,7 +807,7 @@ const makeHasAndBelongsToManyMethod = (table, qb, relation, relationName, query)
     [afk]: query.shape[apk]
   };
   const subQuery = Object.create(__table);
-  subQuery.query = __spreadValues$2({}, subQuery.query);
+  subQuery.query = __spreadValues$4({}, subQuery.query);
   const state = {
     relatedTableQuery: query,
     joinTableQuery: subQuery,
@@ -1237,33 +1241,33 @@ function transaction(fn) {
   });
 }
 
-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) => {
+var __defProp$3 = 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$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$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]);
+    if (__hasOwnProp$6.call(b, prop))
+      __defNormalProp$3(a, prop, b[prop]);
+  if (__getOwnPropSymbols$6)
+    for (var prop of __getOwnPropSymbols$6(b)) {
+      if (__propIsEnum$6.call(b, prop))
+        __defNormalProp$3(a, prop, b[prop]);
     }
   return a;
 };
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __objRest = (source, exclude) => {
+var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
+var __objRest$3 = (source, exclude) => {
   var target = {};
   for (var prop in source)
-    if (__hasOwnProp$1.call(source, prop) && exclude.indexOf(prop) < 0)
+    if (__hasOwnProp$6.call(source, prop) && exclude.indexOf(prop) < 0)
       target[prop] = source[prop];
-  if (source != null && __getOwnPropSymbols$1)
-    for (var prop of __getOwnPropSymbols$1(source)) {
-      if (exclude.indexOf(prop) < 0 && __propIsEnum$1.call(source, prop))
+  if (source != null && __getOwnPropSymbols$6)
+    for (var prop of __getOwnPropSymbols$6(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$6.call(source, prop))
         target[prop] = source[prop];
     }
   return target;
@@ -1274,7 +1278,7 @@ const orchidORM = (_a, tables) => {
     logger,
     autoPreparedStatements,
     noPrimaryKey = "error"
-  } = _b, options = __objRest(_b, [
+  } = _b, options = __objRest$3(_b, [
     "log",
     "logger",
     "autoPreparedStatements",
@@ -1309,7 +1313,7 @@ const orchidORM = (_a, tables) => {
     }
     const table = new tables[key]();
     tableInstances[key] = table;
-    const options2 = __spreadProps(__spreadValues$1({}, commonOptions), {
+    const options2 = __spreadProps$2(__spreadValues$3({}, commonOptions), {
       schema: table.schema
     });
     if (table.noPrimaryKey)
@@ -1330,24 +1334,24 @@ const orchidORM = (_a, tables) => {
   return result;
 };
 
-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) => {
+var __defProp$2 = Object.defineProperty;
+var __getOwnPropSymbols$5 = Object.getOwnPropertySymbols;
+var __hasOwnProp$5 = Object.prototype.hasOwnProperty;
+var __propIsEnum$5 = 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.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]);
+    if (__hasOwnProp$5.call(b, prop))
+      __defNormalProp$2(a, prop, b[prop]);
+  if (__getOwnPropSymbols$5)
+    for (var prop of __getOwnPropSymbols$5(b)) {
+      if (__propIsEnum$5.call(b, prop))
+        __defNormalProp$2(a, prop, b[prop]);
     }
   return a;
 };
 const createRepo = (table, methods) => {
-  const queryMethods = __spreadValues(__spreadValues(__spreadValues(__spreadValues({}, methods.queryMethods), methods.queryOneMethods), methods.queryWithWhereMethods), methods.queryOneWithWhereMethods);
+  const queryMethods = __spreadValues$2(__spreadValues$2(__spreadValues$2(__spreadValues$2({}, methods.queryMethods), methods.queryOneMethods), methods.queryWithWhereMethods), methods.queryOneWithWhereMethods);
   const plainMethods = methods.methods;
   const repo = (q2) => {
     const proto = Object.create(q2.__table);
@@ -1373,5 +1377,913 @@ const createRepo = (table, methods) => {
   });
 };
 
-export { createBaseTable, createRepo, orchidORM };
+const toPascalCase = (s) => {
+  const words = s.match(/(\w)(\w*)/g) || [];
+  return words.map((word) => word[0].toUpperCase() + word.slice(1)).join("");
+};
+const toCamelCase = (s) => {
+  const pascal = toPascalCase(s);
+  return pascal[0].toLowerCase() + pascal.slice(1);
+};
+
+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 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 getRelativePath = (from, to) => {
+  const rel = path__default.relative(path__default.dirname(from), to);
+  return rel.startsWith("./") || rel.startsWith("../") ? rel : `./${rel}`;
+};
+const getImportPath = (from, to) => {
+  return getRelativePath(from, to).replace(/\.[tj]s$/, "");
+};
+
+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) => {
+  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);
+  }
+};
+const createTable$1 = ({ filePath, tablePath, statements, object, content, spaces }, ast) => {
+  const key = toCamelCase(ast.name);
+  const value = toPascalCase(ast.name);
+  const changes = new FileChanges(content);
+  const importPath = getImportPath(filePath, tablePath(ast.name));
+  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(ast.name));
+  const tableClassName = toPascalCase(ast.name);
+  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;
+};
+
+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
+  } = _b, params = __objRest$2(_b, [
+    "ast"
+  ]);
+  const tablePath = params.tablePath(ast.name);
+  const baseTablePath = getImportPath(tablePath, params.baseTablePath);
+  const props = [`table = ${singleQuote(ast.name)};`];
+  if (ast.noPrimaryKey === "ignore") {
+    props.push("noPrimaryKey = true;");
+  }
+  props.push(
+    "columns = this.setColumns((t) => ({",
+    columnsShapeToCode(ast.shape, ast, "t"),
+    "}));"
+  );
+  const code = [
+    `import { ${params.baseTableName} } from '${baseTablePath}';
+`,
+    `export class ${toPascalCase(ast.name)} extends ${params.baseTableName} {`,
+    props,
+    "}\n"
+  ];
+  await fs.mkdir(path__default.dirname(tablePath), { recursive: true });
+  await fs.writeFile(tablePath, codeToString(code, "", "  "));
+};
+
+var __getOwnPropSymbols$3 = Object.getOwnPropertySymbols;
+var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
+var __propIsEnum$3 = Object.prototype.propertyIsEnumerable;
+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
+  } = _b, params = __objRest$1(_b, [
+    "ast"
+  ]);
+  const tablePath = params.tablePath(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);
+  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());
+};
+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.foreignKeys);
+      }
+    } 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 && 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 = {};
+  for (const item of items.reverse()) {
+    if (!ts.is.propertyAccess(item.expression))
+      continue;
+    const { name } = item.expression;
+    const key = name.escapedText.toString();
+    if (!propsToChange[key])
+      continue;
+    const value = getColumnMethodArgs(to, key);
+    if (value) {
+      const code = [`${key}(`];
+      addCode(code, value);
+      addCode(code, ")");
+      changes.replace(name.pos, item.end, codeToString(code, "", "  ").trim());
+    } else {
+      changes.remove(item.expression.expression.end, item.end);
+    }
+    changedProps[key] = true;
+  }
+  let append = "";
+  for (const key in propsToChange) {
+    if (changedProps[key])
+      continue;
+    const value = getColumnMethodArgs(to, key);
+    if (value !== void 0) {
+      const code = [`.${key}(`];
+      addCode(code, value);
+      addCode(code, ")");
+      append += codeToString(code, "", "  ").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}`);
+  }
+  for (const item of add.indexes) {
+    const code = codeToString(indexToCode(item, t), spaces + "  ", "  ");
+    changes.add(end, `  ${code.trim()}
+${spaces}`);
+  }
+  for (const item of add.foreignKeys) {
+    const code = codeToString(foreignKeyToCode(item, t), spaces + "  ", "  ");
+    changes.add(end, `  ${code.trim()}
+${spaces}`);
+  }
+};
+const getColumnMethodArgs = (to, key) => {
+  const value = to[key];
+  if (!value)
+    return;
+  if (key === "collate" || key === "compression") {
+    return singleQuote(value);
+  } else if (key === "default") {
+    return columnDefaultArgumentToCode(value);
+  } else if (key === "nullable" || key === "primaryKey") {
+    return "";
+  } else {
+    return;
+  }
+};
+const dropMatchingIndexes = (context, prop, i, call, items) => {
+  if (!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.length)
+    return;
+  const { arguments: args } = call;
+  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]) || {};
+  for (const item of items) {
+    const itemOptions = item.options;
+    delete itemOptions.dropMode;
+    if (deepCompare(columns, item.columns) && deepCompare(fnOrTable, item.fnOrTable.toString()) && deepCompare(foreignColumns, item.foreignColumns) && deepCompare(options, itemOptions)) {
+      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;
+};
+const deepCompare = (a, b) => {
+  if (typeof a !== typeof b)
+    return false;
+  if (a === b)
+    return true;
+  if (typeof a === "object") {
+    if (a === null)
+      return b === null;
+    if (Array.isArray(a)) {
+      if (!Array.isArray(b) || a.length !== b.length)
+        return false;
+      return a.every((item, i) => deepCompare(item, b[i]));
+    }
+    for (const key in a) {
+      if (!deepCompare(
+        a[key],
+        b[key]
+      ))
+        return false;
+    }
+    for (const key in b) {
+      if (!(key in a))
+        return false;
+    }
+  }
+  return true;
+};
+
+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
+  } = _b, params = __objRest(_b, [
+    "ast"
+  ]);
+  var _a2;
+  const tablePath = params.tablePath(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);
+  for (const node of ts.class.iterate(statements)) {
+    if (((_a2 = node.name) == null ? void 0 : _a2.escapedText) !== className)
+      continue;
+    for (const member of node.members) {
+      const name = ts.prop.getName(member);
+      if (name !== "table")
+        continue;
+      const { initializer: value } = member;
+      if (!value)
+        continue;
+      changes.replace(value.pos, value.end, ` ${singleQuote(ast.to)}`);
+    }
+  }
+  await fs.writeFile(params.tablePath(ast.to), changes.apply());
+};
+
+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 }));
+  }
+};
+
+const createBaseTableFile = async ({
+  baseTableName,
+  baseTablePath
+}) => {
+  await fs.mkdir(path__default.dirname(baseTablePath), { recursive: true });
+  await fs.writeFile(
+    baseTablePath,
+    `import { createBaseTable } from 'orchid-orm';
+import { columnTypes } from 'pqb';
+
+export const ${baseTableName} = createBaseTable({
+  columnTypes: {
+    ...columnTypes,
+  },
+});
+`,
+    {
+      flag: "wx"
+    }
+  ).catch((err) => {
+    if (err.code === "EEXIST")
+      return;
+    throw err;
+  });
+};
+
+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 appCodeUpdater = (config) => {
+  const params = __spreadProps(__spreadValues({}, config), {
+    tablePath: (name) => path.resolve(config.tablePath(name)),
+    mainFilePath: path.resolve(config.mainFilePath)
+  });
+  return async ({ ast, options, cache: cacheObject }) => {
+    const promises = [
+      updateMainFile(params.mainFilePath, params.tablePath, ast, options),
+      updateTableFile(__spreadProps(__spreadValues({}, params), { ast }))
+    ];
+    const cache = cacheObject;
+    if (!cache.createdBaseTable) {
+      promises.push(
+        createBaseTableFile(params).then(() => {
+          cache.createdBaseTable = true;
+        })
+      );
+    }
+    await Promise.all(promises);
+  };
+};
+
+export { AppCodeUpdaterError, appCodeUpdater, createBaseTable, createRepo, orchidORM };
 //# sourceMappingURL=index.esm.js.map