pqb 0.42.6 → 0.42.8

package/dist/index.js

@@ -331,6 +331,58 @@ class ColumnType extends orchidCore.ColumnTypeBase {
       name: typeof args[0] === "string" ? args[0] : void 0
     });
   }
+  /**
+   * Add [EXCLUDE constraint](https://www.postgresql.org/docs/current/sql-createtable.html#SQL-CREATETABLE-EXCLUDE) to the column.
+   *
+   * ```ts
+   * import { change } from '../dbScript';
+   *
+   * change(async (db) => {
+   *   await db.createTable('table', (t) => ({
+   *     // exclude rows with overlapping time ranges, && is for the `WITH` operator
+   *     timeRange: t.type('tstzrange').exclude('&&'),
+   *     // with a database-level name:
+   *     timeRange: t.type('tstzrange').exclude('&&', 'no_overlap'),
+   *     // with options:
+   *     timeRange: t.type('tstzrange').exclude('&&', { ...options }),
+   *     // with name and options:
+   *     name: t.type('tstzrange').exclude('&&', 'no_overlap', { ...options }),
+   *   }));
+   * });
+   * ```
+   *
+   * Possible options are:
+   *
+   * ```ts
+   * interface ExcludeColumnOptions {
+   *   // specify collation:
+   *   collate?: string;
+   *   // see `opclass` in the Postgres document for creating the index
+   *   opclass?: string;
+   *   // specify index order such as ASC NULLS FIRST, DESC NULLS LAST
+   *   order?: string;
+   *   // algorithm to use such as GIST, GIN
+   *   using?: string;
+   *   // EXCLUDE creates an index under the hood, include columns to the index
+   *   include?: MaybeArray<string>;
+   *   // see "storage parameters" in the Postgres document for creating an index, for example, 'fillfactor = 70'
+   *   with?: string;
+   *   // The tablespace in which to create the constraint. If not specified, default_tablespace is consulted, or temp_tablespaces for indexes on temporary tables.
+   *   tablespace?: string;
+   *   // WHERE clause to filter records for the constraint
+   *   where?: string;
+   *   // for dropping the index at a down migration
+   *   dropMode?: DropMode;
+   * }
+   * ```
+   */
+  exclude(...args) {
+    return orchidCore.pushColumnData(this, "excludes", {
+      with: args[0],
+      options: (typeof args[1] === "string" ? args[2] : args[1]) ?? orchidCore.emptyObject,
+      name: typeof args[1] === "string" ? args[1] : void 0
+    });
+  }
   comment(comment) {
     return orchidCore.setColumnData(this, "comment", comment);
   }
@@ -364,7 +416,21 @@ class ColumnType extends orchidCore.ColumnTypeBase {
    */
   generated(...args) {
     const sql = raw(...args);
-    return orchidCore.setColumnData(this, "generated", (...args2) => sql.toSQL(...args2));
+    return orchidCore.setColumnData(this, "generated", {
+      toSQL(ctx, quoted) {
+        return sql.toSQL(ctx, quoted);
+      },
+      toCode() {
+        let sql2 = ".generated";
+        if (Array.isArray(args[0])) {
+          sql2 += orchidCore.templateLiteralSQLToCode(args);
+        } else {
+          const { raw: raw2, values } = args[0];
+          sql2 += `({ raw: '${raw2.replace(/'/g, "\\'")}'${values ? `, values: ${JSON.stringify(values)}` : ""} })`;
+        }
+        return sql2;
+      }
+    });
   }
 }
 
@@ -441,20 +507,12 @@ const columnsShapeToCode = (ctx, shape) => {
   return code;
 };
 const pushTableDataCode = (code, ast) => {
-  const lines = [];
-  if (ast.primaryKey) {
-    lines.push([primaryKeyInnerToCode(ast.primaryKey, "t") + ","]);
-  }
-  if (ast.indexes) {
-    for (const index of ast.indexes) {
-      lines.push(indexToCode(index, "t"));
-    }
-  }
-  if (ast.constraints) {
-    for (const constraint of ast.constraints) {
-      lines.push(constraintToCode(constraint, "t", true));
-    }
-  }
+  const lines = [
+    ast.primaryKey && [primaryKeyInnerToCode(ast.primaryKey, "t") + ","],
+    ...ast.indexes?.map((x) => indexToCode(x, "t")) || orchidCore.emptyArray,
+    ...ast.excludes?.map((x) => excludeToCode(x, "t")) || orchidCore.emptyArray,
+    ...ast.constraints?.map((x) => constraintToCode(x, "t", true)) || orchidCore.emptyArray
+  ].filter((x) => !!x);
   if (lines.length > 1) {
     code.push("(t) => [", ...lines, "],");
   } else if (lines[0].length === 1 && typeof lines[0][0] === "string") {
@@ -468,18 +526,17 @@ const primaryKeyInnerToCode = (primaryKey, t) => {
   const name = primaryKey.name;
   return `${t}.primaryKey([${primaryKey.columns.map(orchidCore.singleQuote).join(", ")}]${name ? `, ${orchidCore.singleQuote(name)}` : ""})`;
 };
-const indexToCode = (index, t, prefix) => {
-  const code = indexInnerToCode(index, t);
+const indexOrExcludeToCode = (innerToCode) => (item, t, prefix) => {
+  const code = innerToCode(item, t);
   if (prefix) code[0] = prefix + code[0];
   const last = code[code.length - 1];
   if (typeof last === "string" && !last.endsWith(",")) orchidCore.addCode(code, ",");
   return code;
 };
 const indexInnerToCode = (index, t) => {
-  const code = [];
-  code.push(
+  const code = [
     `${t}.${index.options.tsVector ? "searchIndex" : index.options.unique ? "unique" : "index"}(`
-  );
+  ];
   const columnOptions = ["collate", "opclass", "order", "weight"];
   const indexOptionsKeys = [
     index.options.tsVector ? "unique" : void 0,
@@ -570,6 +627,54 @@ const indexInnerToCode = (index, t) => {
   }
   return code;
 };
+const indexToCode = indexOrExcludeToCode(indexInnerToCode);
+const excludeInnerToCode = (item, t) => {
+  const code = [`${t}.exclude(`];
+  const columnOptions = ["collate", "opclass", "order", "with"];
+  const optionsKeys = [
+    "using",
+    "include",
+    "with",
+    "tablespace",
+    "where",
+    "dropMode"
+  ];
+  const hasOptions = optionsKeys.some((key) => key && item.options[key]);
+  const objects = [];
+  for (const column of item.columns) {
+    const expr = "column" in column ? column.column : column.expression;
+    const props = [
+      `${"column" in column ? "column" : "expression"}: ${orchidCore.singleQuote(expr)},`
+    ];
+    for (const key of columnOptions) {
+      const value = column[key];
+      if (value !== void 0) {
+        props.push(`${key}: ${orchidCore.singleQuote(value)},`);
+      }
+    }
+    objects.push("{", props, "},");
+  }
+  code.push(["[", objects, hasOptions || item.name ? "]," : "]"]);
+  if (item.name) {
+    orchidCore.addCode(code, `  ${orchidCore.singleQuote(item.name)},`);
+  }
+  if (hasOptions) {
+    code.push(["{"]);
+    const options = [];
+    for (const key of optionsKeys) {
+      if (!key) continue;
+      const value = item.options[key];
+      if (value === null || value === void 0) continue;
+      options.push(
+        `${key}: ${Array.isArray(value) ? orchidCore.singleQuoteArray(value) : typeof value === "string" ? orchidCore.singleQuote(value) : value},`
+      );
+    }
+    code.push([options, "},"]);
+  }
+  code.push("),");
+  return code;
+};
+const excludeToCode = indexOrExcludeToCode(excludeInnerToCode);
 const constraintToCode = (item, t, m, prefix) => {
   const code = constraintInnerToCode(item, t, m);
   if (prefix) code[0] = prefix + code[0];
@@ -658,25 +763,22 @@ const foreignKeyArgumentToCode = ({
   }
   return code;
 };
-const columnIndexesToCode = (indexes) => {
+const columnIndexesToCode = (items) => {
   const code = [];
-  for (const { options, name } of indexes) {
+  for (const { options, name } of items) {
     orchidCore.addCode(code, `.${options.unique ? "unique" : "index"}(`);
-    const arr = [];
-    if (options.collate) arr.push(`collate: ${orchidCore.singleQuote(options.collate)},`);
-    if (options.opclass) arr.push(`opclass: ${orchidCore.singleQuote(options.opclass)},`);
-    if (options.order) arr.push(`order: ${orchidCore.singleQuote(options.order)},`);
-    if (name) arr.push(`name: ${orchidCore.singleQuote(name)},`);
-    if (options.using) arr.push(`using: ${orchidCore.singleQuote(options.using)},`);
-    if (options.include)
-      arr.push(
-        `include: ${typeof options.include === "string" ? orchidCore.singleQuote(options.include) : `[${options.include.map(orchidCore.singleQuote).join(", ")}]`},`
-      );
-    if (options.nullsNotDistinct) arr.push(`nullsNotDistinct: true,`);
-    if (options.with) arr.push(`with: ${orchidCore.singleQuote(options.with)},`);
-    if (options.tablespace)
-      arr.push(`tablespace: ${orchidCore.singleQuote(options.tablespace)},`);
-    if (options.where) arr.push(`where: ${orchidCore.singleQuote(options.where)},`);
+    const arr = [
+      options.collate && `collate: ${orchidCore.singleQuote(options.collate)},`,
+      options.opclass && `opclass: ${orchidCore.singleQuote(options.opclass)},`,
+      options.order && `order: ${orchidCore.singleQuote(options.order)},`,
+      name && `name: ${orchidCore.singleQuote(name)},`,
+      options.using && `using: ${orchidCore.singleQuote(options.using)},`,
+      options.include && `include: ${typeof options.include === "string" ? orchidCore.singleQuote(options.include) : `[${options.include.map(orchidCore.singleQuote).join(", ")}]`},`,
+      options.nullsNotDistinct && `nullsNotDistinct: true,`,
+      options.with && `with: ${orchidCore.singleQuote(options.with)},`,
+      options.tablespace && `tablespace: ${orchidCore.singleQuote(options.tablespace)},`,
+      options.where && `where: ${orchidCore.singleQuote(options.where)},`
+    ].filter((x) => !!x);
     if (arr.length) {
       orchidCore.addCode(code, "{");
       orchidCore.addCode(code, arr);
@@ -686,6 +788,30 @@ const columnIndexesToCode = (indexes) => {
   }
   return code;
 };
+const columnExcludesToCode = (items) => {
+  const code = [];
+  for (const { options, name, with: w } of items) {
+    orchidCore.addCode(code, `.exclude('${w}'`);
+    const arr = [
+      options.collate && `collate: ${orchidCore.singleQuote(options.collate)},`,
+      options.opclass && `opclass: ${orchidCore.singleQuote(options.opclass)},`,
+      options.order && `order: ${orchidCore.singleQuote(options.order)},`,
+      name && `name: ${orchidCore.singleQuote(name)},`,
+      options.using && `using: ${orchidCore.singleQuote(options.using)},`,
+      options.include && `include: ${typeof options.include === "string" ? orchidCore.singleQuote(options.include) : `[${options.include.map(orchidCore.singleQuote).join(", ")}]`},`,
+      options.with && `with: ${orchidCore.singleQuote(options.with)},`,
+      options.tablespace && `tablespace: ${orchidCore.singleQuote(options.tablespace)},`,
+      options.where && `where: ${orchidCore.singleQuote(options.where)},`
+    ].filter((x) => !!x);
+    if (arr.length) {
+      orchidCore.addCode(code, ", {");
+      orchidCore.addCode(code, arr);
+      orchidCore.addCode(code, "}");
+    }
+    orchidCore.addCode(code, ")");
+  }
+  return code;
+};
 const columnCheckToCode = (ctx, { sql, name }, columnName) => {
   return `.check(${sql.toCode(ctx.t)}${name && name !== `${ctx.table}_${columnName}_check` ? `, { name: '${name}' }` : ""})`;
 };
@@ -728,6 +854,9 @@ const columnCode = (type, ctx, key, code) => {
   } else {
     code[0].unshift(prepend);
   }
+  if (data.generated) {
+    orchidCore.addCode(code, data.generated.toCode());
+  }
   if (data.primaryKey) {
     orchidCore.addCode(
       code,
@@ -762,6 +891,11 @@ const columnCode = (type, ctx, key, code) => {
       orchidCore.addCode(code, part);
     }
   }
+  if (data.excludes) {
+    for (const part of columnExcludesToCode(data.excludes)) {
+      orchidCore.addCode(code, part);
+    }
+  }
   if (data.comment) orchidCore.addCode(code, `.comment(${orchidCore.singleQuote(data.comment)})`);
   if (data.check) {
     orchidCore.addCode(code, columnCheckToCode(ctx, data.check, name));
@@ -1322,32 +1456,59 @@ class TsVectorColumn extends ColumnType {
    * @param args
    */
   generated(...args) {
-    return orchidCore.setColumnData(this, "generated", (ctx, quotedAs) => {
+    const arg = args[0];
+    if (typeof arg === "object" && "raw" in arg) {
+      return super.generated(...args);
+    }
+    const toSQL = (ctx) => {
       const first = args[0];
-      if (typeof first === "string" || !("raw" in first)) {
-        const target = typeof first === "string" ? args[1] : first;
-        const language = typeof first === "string" ? first : this.defaultLanguage;
-        const { snakeCase } = ctx;
-        let sql;
-        if (Array.isArray(target)) {
-          const columns = target.length === 1 ? `"${snakeCase ? orchidCore.toSnakeCase(target[0]) : target[0]}"` : target.map(
-            (column) => `coalesce("${snakeCase ? orchidCore.toSnakeCase(column) : column}", '')`
-          ).join(` || ' ' || `);
-          sql = `to_tsvector('${language}', ${columns})`;
+      const target = typeof first === "string" ? args[1] : first;
+      const language = typeof first === "string" ? first : this.defaultLanguage;
+      const { snakeCase } = ctx;
+      let sql;
+      if (Array.isArray(target)) {
+        const columns = target.length === 1 ? `"${snakeCase ? orchidCore.toSnakeCase(target[0]) : target[0]}"` : target.map(
+          (column) => `coalesce("${snakeCase ? orchidCore.toSnakeCase(column) : column}", '')`
+        ).join(` || ' ' || `);
+        sql = `to_tsvector('${language}', ${columns})`;
+      } else {
+        for (const key in target) {
+          sql = (sql ? sql + " || " : "(") + `setweight(to_tsvector('${language}', coalesce("${snakeCase ? orchidCore.toSnakeCase(key) : key}", '')), '${target[key]}')`;
+        }
+        if (sql) {
+          sql += ")";
         } else {
-          for (const key in target) {
-            sql = (sql ? sql + " || " : "(") + `setweight(to_tsvector('${language}', coalesce("${snakeCase ? orchidCore.toSnakeCase(key) : key}", '')), '${target[key]}')`;
-          }
-          if (sql) {
-            sql += ")";
-          } else {
-            throw new Error("Empty target in the text search generated column");
-          }
+          throw new Error("Empty target in the text search generated column");
         }
-        return sql;
+      }
+      return sql;
+    };
+    const toCode = () => {
+      let code = ".generated(";
+      const first = args[0];
+      let target;
+      if (typeof first === "string") {
+        code += `'${first}', `;
+        target = args[1];
       } else {
-        return raw(...args).toSQL(ctx, quotedAs);
+        target = args[0];
       }
+      if (Array.isArray(target)) {
+        code += `[${target.map((x) => `'${x}'`).join(", ")}]`;
+      } else {
+        const pairs = [];
+        for (const key in target) {
+          pairs.push(
+            `${orchidCore.quoteObjectKey(key)}: '${target[key]}'`
+          );
+        }
+        code += `{ ${pairs.join(", ")} }`;
+      }
+      return code + ")";
+    };
+    return orchidCore.setColumnData(this, "generated", {
+      toSQL,
+      toCode
     });
   }
 }
@@ -11986,6 +12147,19 @@ const tableDataMethods = {
     input.index.options.tsVector = true;
     return input;
   },
+  exclude(columns, ...[first, second]) {
+    if (typeof first === "string") {
+      const options = second ?? {};
+      return {
+        exclude: { columns, options, name: first }
+      };
+    } else {
+      const options = first ?? {};
+      return {
+        exclude: { columns, options }
+      };
+    }
+  },
   foreignKey(columns, fnOrTable, foreignColumns, options) {
     return {
       constraint: {
@@ -12017,15 +12191,13 @@ const parseTableDataInput = (tableData, item) => {
   if (item.primaryKey) {
     tableData.primaryKey = item.primaryKey;
   } else if (item.index) {
-    const index = item.index;
-    for (let i = index.columns.length - 1; i >= 0; i--) {
-      if (typeof index.columns[i] === "string") {
-        index.columns[i] = {
-          column: index.columns[i]
-        };
-      }
-    }
-    (tableData.indexes ?? (tableData.indexes = [])).push(item.index);
+    (tableData.indexes ?? (tableData.indexes = [])).push(
+      parseIndexOrExclude(item.index)
+    );
+  } else if (item.exclude) {
+    (tableData.excludes ?? (tableData.excludes = [])).push(
+      parseIndexOrExclude(item.exclude)
+    );
   } else if (item.constraint) {
     (tableData.constraints ?? (tableData.constraints = [])).push(item.constraint);
     if (item.constraint.references?.options?.dropMode) {
@@ -12033,6 +12205,16 @@ const parseTableDataInput = (tableData, item) => {
     }
   }
 };
+const parseIndexOrExclude = (item) => {
+  for (let i = item.columns.length - 1; i >= 0; i--) {
+    if (typeof item.columns[i] === "string") {
+      item.columns[i] = {
+        column: item.columns[i]
+      };
+    }
+  }
+  return item;
+};
 
 const anyShape = {};
 class Db extends QueryMethods {
@@ -12674,6 +12856,7 @@ exports.cloneQuery = cloneQuery;
 exports.cloneQueryBaseUnscoped = cloneQueryBaseUnscoped;
 exports.columnCheckToCode = columnCheckToCode;
 exports.columnCode = columnCode;
+exports.columnExcludesToCode = columnExcludesToCode;
 exports.columnForeignKeysToCode = columnForeignKeysToCode;
 exports.columnIndexesToCode = columnIndexesToCode;
 exports.columnsShapeToCode = columnsShapeToCode;
@@ -12687,6 +12870,8 @@ exports.defaultSchemaConfig = defaultSchemaConfig;
 exports.escapeForLog = escapeForLog;
 exports.escapeForMigration = escapeForMigration;
 exports.escapeString = escapeString;
+exports.excludeInnerToCode = excludeInnerToCode;
+exports.excludeToCode = excludeToCode;
 exports.extendQuery = extendQuery;
 exports.filterResult = filterResult;
 exports.foreignKeyArgumentToCode = foreignKeyArgumentToCode;