rake-db 2.10.1 → 2.10.3

package/dist/index.d.ts

@@ -41,6 +41,7 @@ type TableOptions = {
     comment?: string;
     noPrimaryKey?: boolean;
     snakeCase?: boolean;
+    language?: string;
 };
 type TextColumnCreator = () => TextColumn;
 type MigrationColumnTypes<CT extends ColumnTypesBase> = Omit<CT, 'text' | 'string' | 'enum'> & {
@@ -54,6 +55,7 @@ type ColumnsShapeCallback<CT extends ColumnTypesBase, Shape extends ColumnsShape
 }) => Shape;
 type ChangeTableOptions = {
     snakeCase?: boolean;
+    language?: string;
     comment?: string | [string, string] | null;
 };
 type ChangeTableCallback<CT extends ColumnTypesBase> = (t: TableChanger<CT>) => TableChangeData;
@@ -941,6 +943,7 @@ type BaseTable<CT extends ColumnTypesBase> = {
     new (): {
         columnTypes: CT;
         snakeCase?: boolean;
+        language?: string;
     };
 };
 type InputRakeDbConfig<CT extends ColumnTypesBase> = Partial<Omit<RakeDbConfig<CT>, 'columnTypes'>> & ({
@@ -956,6 +959,7 @@ type RakeDbConfig<CT extends ColumnTypesBase = DefaultColumnTypes> = {
     recurrentPath: string;
     migrationsTable: string;
     snakeCase: boolean;
+    language?: string;
     commands: Record<string, (options: AdapterOptions[], config: RakeDbConfig<CT>, args: string[]) => Promise<void>>;
     import(path: string): Promise<unknown>;
     noPrimaryKey?: NoPrimaryKeyOption;
@@ -1095,39 +1099,24 @@ declare const rakeDb: <CT extends Record<string, orchid_core.AnyColumnTypeCreato
     tsquery(): pqb.TsQueryColumn;
     uuid(): pqb.UUIDColumn;
     xml(): pqb.XMLColumn;
-    json<Type extends orchid_core.JSONTypeAny>(schemaOrFn: Type | ((j: {
-        set: <Value extends orchid_core.JSONTypeAny>(valueType: Value) => orchid_core.JSONSet<Value>;
-        tuple: <T_5 extends [] | orchid_core.JSONTupleItems, Rest extends orchid_core.JSONTypeAny | null = null>(items: T_5, rest?: Rest) => orchid_core.JSONTuple<T_5, Rest>;
-        union: <T_6 extends [orchid_core.JSONTypeAny, orchid_core.JSONTypeAny, ...orchid_core.JSONTypeAny[]]>(types: T_6) => orchid_core.JSONUnion<T_6>;
-        any: () => orchid_core.JSONAny;
-        bigint: () => orchid_core.JSONBigInt;
+    json<Type extends orchid_core.JSONType<unknown, {}> = orchid_core.JSONUnknown>(schemaOrFn?: Type | ((j: {
+        unknown: () => orchid_core.JSONUnknown;
         boolean: () => orchid_core.JSONBoolean;
-        date: () => orchid_core.JSONDate;
-        nan: () => orchid_core.JSONNaN;
-        never: () => orchid_core.JSONNever;
         null: () => orchid_core.JSONNull;
         number: () => orchid_core.JSONNumber;
         string: () => orchid_core.JSONString;
-        unknown: () => orchid_core.JSONUnknown;
-        array: <Type_1 extends orchid_core.JSONTypeAny>(element: Type_1) => orchid_core.JSONArray<Type_1, "many">;
-        discriminatedUnion: <Discriminator extends string, DiscriminatorValue extends orchid_core.Primitive, Types extends [orchid_core.JSONDiscriminatedObject<Discriminator, DiscriminatorValue>, orchid_core.JSONDiscriminatedObject<Discriminator, DiscriminatorValue>, ...orchid_core.JSONDiscriminatedObject<Discriminator, DiscriminatorValue>[]]>(discriminator: Discriminator, options: Types) => orchid_core.JSONDiscriminatedUnion<Discriminator, DiscriminatorValue, Types>;
-        enum: <U_1 extends string, T_7 extends [U_1, ...U_1[]]>(options: T_7) => orchid_core.JSONEnum<U_1, T_7>;
-        instanceOf: <T_8 extends new (...args: any[]) => any>(cls: T_8) => orchid_core.JSONInstanceOf<T_8>;
-        intersection: <Left extends orchid_core.JSONTypeAny, Right extends orchid_core.JSONTypeAny>(left: Left, right: Right) => orchid_core.JSONIntersection<Left, Right>;
-        lazy: <T_9 extends orchid_core.JSONTypeAny>(fn: () => T_9) => orchid_core.JSONLazy<T_9>;
-        literal: <T_10 extends orchid_core.Primitive>(value: T_10) => orchid_core.JSONLiteral<T_10>;
-        map: <Key extends orchid_core.JSONTypeAny, Value_1 extends orchid_core.JSONTypeAny>(keyType: Key, valueType: Value_1) => orchid_core.JSONMap<Key, Value_1>;
-        nativeEnum: <T_11 extends orchid_core.EnumLike>(givenEnum: T_11) => orchid_core.JSONNativeEnum<T_11>;
-        nullable: <T_12 extends orchid_core.JSONTypeAny>(type: T_12) => orchid_core.JSONNullable<T_12>;
-        nullish: <T_13 extends orchid_core.JSONTypeAny>(type: T_13) => orchid_core.JSONNullish<T_13>;
-        object: <T_14 extends orchid_core.JSONObjectShape, UnknownKeys extends orchid_core.UnknownKeysParam = "strip", Catchall extends orchid_core.JSONTypeAny = orchid_core.JSONTypeAny>(shape: T_14) => orchid_core.JSONObject<T_14, UnknownKeys, Catchall, orchid_core.JSONTypeAny extends Catchall ? orchid_core.addQuestionMarks<{ [k_1 in keyof T_14]: T_14[k_1]["type"]; }> extends infer T_15 extends object ? { [k in keyof T_15]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_14]: T_14[k_1]["type"]; }>[k]; } : never : (orchid_core.addQuestionMarks<{ [k_1 in keyof T_14]: T_14[k_1]["type"]; }> extends infer T_18 extends object ? { [k in keyof T_18]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_14]: T_14[k_1]["type"]; }>[k]; } : never) & {
-            [k: string]: Catchall["type"];
-        } extends infer T_16 extends object ? { [k_2 in keyof T_16]: ((orchid_core.addQuestionMarks<{ [k_1 in keyof T_14]: T_14[k_1]["type"]; }> extends infer T_17 extends object ? { [k in keyof T_17]: orchid_core.addQuestionMarks<{ [k_1 in keyof T_14]: T_14[k_1]["type"]; }>[k]; } : never) & {
-            [k: string]: Catchall["type"];
-        })[k_2]; } : never>;
-        optional: <T_19 extends orchid_core.JSONTypeAny>(type: T_19) => orchid_core.JSONOptional<T_19>;
-        record: typeof orchid_core.record;
-    }) => Type)): pqb.JSONColumn<Type>;
+        array: <T_5 extends orchid_core.JSONType<unknown, {}>>(item: T_5) => orchid_core.JSONArray<T_5, "many">;
+        object: <Shape extends orchid_core.JSONObjectShape>(shape: Shape) => orchid_core.JSONObject<Shape, "strip", orchid_core.JSONType<unknown, {}>>;
+        literal: <T_6 extends orchid_core.JSONPrimitive>(value: T_6) => orchid_core.JSONLiteral<T_6>;
+        discriminatedUnion: <Discriminator extends string, Types extends orchid_core.JSONDiscriminatedUnionArg<Discriminator>>(discriminator: Discriminator, types: Types) => orchid_core.JSONDiscriminatedUnion<Discriminator, Types>;
+        enum: <U_1 extends string, T_7 extends [U_1, ...U_1[]]>(options: T_7) => orchid_core.JSONEnum<string, T_7>;
+        intersection: <Left extends orchid_core.JSONType<unknown, {}>, Right extends orchid_core.JSONType<unknown, {}>>(left: Left, right: Right) => orchid_core.JSONIntersection<Left, Right>;
+        lazy: <T_8 extends orchid_core.JSONType<unknown, {}>>(fn: () => T_8) => orchid_core.JSONLazy<T_8>;
+        nativeEnum: <T_9 extends orchid_core.EnumLike>(type: T_9) => orchid_core.JSONNativeEnum<T_9>;
+        record: <Key extends orchid_core.JSONNumber | orchid_core.JSONString, Value extends orchid_core.JSONType<unknown, {}>>(...args: [value: Value] | [key: Key, value: Value]) => orchid_core.JSONRecord<Key, Value>;
+        tuple: <T_10 extends orchid_core.JSONTupleItems, Rest extends orchid_core.JSONType<unknown, {}> | undefined = undefined>(items: T_10, rest?: Rest | undefined) => orchid_core.JSONTuple<T_10, Rest>;
+        union: <T_11 extends orchid_core.JSONUnionArgs>(...types: T_11) => orchid_core.JSONUnion<T_11>;
+    }) => Type) | undefined): pqb.JSONColumn<Type>;
     jsonText(): pqb.JSONTextColumn;
     array<Item extends pqb.ColumnType<unknown, pqb.BaseOperators, unknown>>(item: Item): pqb.ArrayColumn<Item>;
     type(dataType: string): pqb.CustomTypeColumn;
@@ -1136,7 +1125,8 @@ declare const rakeDb: <CT extends Record<string, orchid_core.AnyColumnTypeCreato
         name?: string | undefined;
     } | undefined): {};
     index(columns: MaybeArray<string | pqb.IndexColumnOptions>, options?: pqb.IndexOptions): {};
-    unique(columns: MaybeArray<string | pqb.IndexColumnOptions>, options?: pqb.IndexOptions): {};
+    unique(columns: MaybeArray<string | pqb.IndexColumnOptions>, options?: pqb.IndexOptions | undefined): {};
+    searchIndex(columns: MaybeArray<string | pqb.IndexColumnOptions>, options?: pqb.IndexOptions | undefined): {};
     constraint<Table extends string | (() => orchid_core.ForeignKeyTable), Columns extends Table extends () => orchid_core.ForeignKeyTable ? [orchid_core.ColumnNameOfTable<ReturnType<Table>>, ...orchid_core.ColumnNameOfTable<ReturnType<Table>>[]] : [string, ...string[]]>({ name, references, check, dropMode, }: {
         name?: string | undefined;
         references?: [columns: string[], fnOrTable: Table, foreignColumns: Columns, options?: pqb.ForeignKeyOptions | undefined] | undefined;

package/dist/index.js

@@ -100,6 +100,8 @@ const processRakeDbConfig = (config) => {
     result.columnTypes = proto.columnTypes || pqb.columnTypes;
     if (proto.snakeCase)
       result.snakeCase = true;
+    if (proto.language)
+      result.language = proto.language;
   } else {
     result.columnTypes = "columnTypes" in config && (typeof config.columnTypes === "function" ? config.columnTypes(pqb.columnTypes) : config.columnTypes) || pqb.columnTypes;
   }
@@ -319,6 +321,10 @@ const columnToSql = (name, item, values, hasMultiplePrimaryKeys, snakeCase) => {
   }
   if (item.data.identity) {
     line.push(identityToSql(item.data.identity));
+  } else if (item.data.generated) {
+    line.push(
+      `GENERATED ALWAYS AS (${item.data.generated.toSQL({ values })}) STORED`
+    );
   }
   if (item.data.isPrimaryKey && !hasMultiplePrimaryKeys) {
     line.push("PRIMARY KEY");
@@ -462,7 +468,7 @@ const getIndexName = (table, columns) => {
     }
   ).join("_")}_idx`;
 };
-const indexesToQuery = (up, { schema, name }, indexes) => {
+const indexesToQuery = (up, { schema, name }, indexes, language) => {
   return indexes.map(({ columns, options }) => {
     const indexName = options.name || getIndexName(name, columns);
     if (!up) {
@@ -477,11 +483,14 @@ const indexesToQuery = (up, { schema, name }, indexes) => {
       sql.push("UNIQUE");
     }
     sql.push(`INDEX "${indexName}" ON ${quoteWithSchema({ schema, name })}`);
-    if (options.using) {
-      sql.push(`USING ${options.using}`);
+    const using = options.using || options.tsVector && "GIN";
+    if (using) {
+      sql.push(`USING ${using}`);
     }
     const columnsSql = [];
-    columns.forEach((column) => {
+    const lang = options.tsVector && options.languageColumn ? `"${options.languageColumn}"` : options.language ? typeof options.language === "string" ? `'${options.language}'` : options.language.toSQL({ values }) : `'${language || "english"}'`;
+    let hasWeight = options.tsVector && columns.some((column) => !!column.weight);
+    for (const column of columns) {
       const columnSql = [
         "column" in column ? `"${column.column}"` : `(${column.expression})`
       ];
@@ -494,9 +503,23 @@ const indexesToQuery = (up, { schema, name }, indexes) => {
       if (column.order) {
         columnSql.push(column.order);
       }
-      columnsSql.push(columnSql.join(" "));
-    });
-    sql.push(`(${columnsSql.join(", ")})`);
+      let sql2 = columnSql.join(" ");
+      if (hasWeight) {
+        sql2 = `to_tsvector(${lang}, coalesce(${sql2}, ''))`;
+        if (column.weight) {
+          hasWeight = true;
+          sql2 = `setweight(${sql2}, '${column.weight}')`;
+        }
+      }
+      columnsSql.push(sql2);
+    }
+    let columnList = columnsSql.join(hasWeight ? " || " : ", ");
+    if (!hasWeight && options.tsVector) {
+      if (columnsSql.length > 1)
+        columnList = `concat_ws(' ', ${columnList})`;
+      columnList = `to_tsvector(${lang}, ${columnList})`;
+    }
+    sql.push(`(${columnList})`);
     if (options.include) {
       sql.push(
         `INCLUDE (${orchidCore.toArray(options.include).map((column) => `"${column}"`).join(", ")})`
@@ -580,12 +603,18 @@ var __objRest$1 = (source, exclude) => {
 const createTable$1 = async (migration, up, tableName, options, fn) => {
   var _a;
   const snakeCase = "snakeCase" in options ? options.snakeCase : migration.options.snakeCase;
+  const language = "language" in options ? options.language : migration.options.language;
   const types = Object.assign(
     Object.create(migration.columnTypes),
     tableMethods
   );
   types[orchidCore.snakeCaseKey] = snakeCase;
-  const shape = pqb.getColumnTypes(types, fn, (_a = migration.options.baseTable) == null ? void 0 : _a.nowSQL);
+  const shape = pqb.getColumnTypes(
+    types,
+    fn,
+    (_a = migration.options.baseTable) == null ? void 0 : _a.nowSQL,
+    language
+  );
   const tableData = pqb.getTableData();
   const ast = makeAst$2(
     up,
@@ -596,7 +625,7 @@ const createTable$1 = async (migration, up, tableName, options, fn) => {
     migration.options.noPrimaryKey
   );
   validatePrimaryKey(ast);
-  const queries = astToQueries$1(ast, snakeCase);
+  const queries = astToQueries$1(ast, snakeCase, language);
   for (const _b of queries) {
     const _c = _b, { then } = _c, query = __objRest$1(_c, ["then"]);
     const result = await migration.adapter.arrays(query);
@@ -664,7 +693,7 @@ You can suppress this error by setting { noPrimaryKey: true } after a table name
     }
   }
 };
-const astToQueries$1 = (ast, snakeCase) => {
+const astToQueries$1 = (ast, snakeCase, language) => {
   var _a, _b;
   const queries = [];
   const { shape } = ast;
@@ -736,7 +765,7 @@ const astToQueries$1 = (ast, snakeCase) => {
 )`,
       values
     },
-    ...indexesToQuery(true, ast, indexes),
+    ...indexesToQuery(true, ast, indexes, language),
     ...commentsToQuery(ast, comments)
   );
   if (ast.comment) {
@@ -916,15 +945,17 @@ const tableChangeMethods = __spreadProps$2(__spreadValues$3({}, tableMethods), {
 });
 const changeTable = async (migration, up, tableName, options, fn) => {
   var _a;
+  const snakeCase = "snakeCase" in options ? options.snakeCase : migration.options.snakeCase;
+  const language = "language" in options ? options.language : migration.options.language;
+  orchidCore.setDefaultLanguage(language);
   pqb.resetTableData();
   resetChangeTableData();
   const tableChanger = Object.create(migration.columnTypes);
   Object.assign(tableChanger, tableChangeMethods);
-  const snakeCase = "snakeCase" in options ? options.snakeCase : migration.options.snakeCase;
   tableChanger[orchidCore.snakeCaseKey] = snakeCase;
   const changeData = (fn == null ? void 0 : fn(tableChanger)) || {};
   const ast = makeAst$1(up, tableName, changeData, changeTableData, options);
-  const queries = astToQueries(ast, snakeCase);
+  const queries = astToQueries(ast, snakeCase, language);
   for (const query of queries) {
     const result = await migration.adapter.arrays(query);
     (_a = query.then) == null ? void 0 : _a.call(query, result);
@@ -957,7 +988,7 @@ const makeAst$1 = (up, name, changeData, changeTableData2, options) => {
     shape
   }, up ? changeTableData2 : { add: changeTableData2.drop, drop: changeTableData2.add });
 };
-const astToQueries = (ast, snakeCase) => {
+const astToQueries = (ast, snakeCase, language) => {
   var _a, _b, _c, _d, _e, _f, _g, _h, _i;
   const queries = [];
   if (ast.comment !== void 0) {
@@ -1202,8 +1233,8 @@ const astToQueries = (ast, snakeCase) => {
       values
     });
   }
-  queries.push(...indexesToQuery(false, ast, dropIndexes));
-  queries.push(...indexesToQuery(true, ast, addIndexes));
+  queries.push(...indexesToQuery(false, ast, dropIndexes, language));
+  queries.push(...indexesToQuery(true, ast, addIndexes, language));
   queries.push(...commentsToQuery(ast, comments));
   return queries;
 };