@tstdl/base 0.93.15 → 0.93.17

package/orm/server/drizzle/schema-converter.js

@@ -1,6 +1,7 @@
-import { sql, SQL } from 'drizzle-orm';
+import { SQL, sql } from 'drizzle-orm';
 import { toCamelCase, toSnakeCase } from 'drizzle-orm/casing';
 import { boolean, check, doublePrecision, foreignKey, index, integer, jsonb, pgSchema, primaryKey, text, unique, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
+import { match, P } from 'ts-pattern';
 import { MultiKeyMap } from '../../../data-structures/multi-key-map.js';
 import { tryGetEnumName } from '../../../enumeration/enumeration.js';
 import { NotSupportedError } from '../../../errors/not-supported.error.js';
@@ -12,10 +13,12 @@ import { compareByValueSelectionToOrder, orderRest } from '../../../utils/compar
 import { decodeText, encodeUtf8 } from '../../../utils/encoding.js';
 import { enumValues } from '../../../utils/enum.js';
 import { memoize, memoizeSingle } from '../../../utils/function/memoize.js';
+import { iif } from '../../../utils/helpers.js';
 import { compileDereferencer } from '../../../utils/object/dereference.js';
 import { fromEntries, objectEntries } from '../../../utils/object/object.js';
 import { assertDefined, assertDefinedPass, isArray, isDefined, isNotNullOrUndefined, isNull, isString, isUndefined } from '../../../utils/type-guards.js';
-import { bytea, numericDate, timestamp } from '../../data-types/index.js';
+import { resolveValueOrProvider } from '../../../utils/value-or-provider.js';
+import { bytea, numericDate, timestamp, tsvector } from '../../data-types/index.js';
 import { JsonSchema } from '../../schemas/json.js';
 import { NumericDateSchema } from '../../schemas/numeric-date.js';
 import { TimestampSchema } from '../../schemas/timestamp.js';
@@ -55,12 +58,9 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
     function buildIndex(table, data, columnName) {
         const columns = (data.columns ?? [columnName]).map((columnValue) => {
             assertDefined(columnValue, 'Missing column name for index.');
-            if (columnValue instanceof SQL) {
-                return columnValue;
-            }
             const [columnName, columnOrder] = isString(columnValue) ? [columnValue] : columnValue;
-            let column = getColumn(table, columnName);
             const order = columnOrder ?? data.order ?? 'asc';
+            let column = getColumn(table, columnName);
             column = column[order]();
             if (data.options?.nulls == 'first') {
                 column = column.nullsFirst();
@@ -71,37 +71,13 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
             return column;
         });
         const indexFn = (data.options?.unique == true) ? uniqueIndex : index;
-        const containsSql = columns.some((column) => column instanceof SQL);
-        const indexName = data.options?.name ?? (containsSql
-            ? assertDefinedPass(data.options?.name, 'Index with SQL expressions must have a name.')
-            : getIndexName(tableName, columns, { naming: data.options?.naming }));
-        const indexColumns = (data.options?.using == 'gin'
-            ? buildGinIndexColumns(columns, data.options)
-            : columns);
-        let builder = indexFn(indexName).using(data.options?.using ?? 'btree', ...indexColumns);
+        let builder = indexFn(data.options?.name ?? getIndexName(tableName, columns, { naming: data.options?.naming })).using(data.options?.using ?? 'btree', ...columns);
         if (isDefined(data.options?.where)) {
             const query = convertQuery(data.options.where(table), table, columnDefinitionsMap);
             builder = builder.where(query.inlineParams());
         }
         return builder;
     }
-    function buildGinIndexColumns(columns, options) {
-        const vectors = columns.map((column) => {
-            if (column instanceof SQL) {
-                return column;
-            }
-            const tsVector = toTsVector(options.language ?? 'simple', column);
-            const weight = options.weights?.[column.name];
-            if (isDefined(weight)) {
-                return setweight(tsVector, weight);
-            }
-            return tsVector;
-        });
-        if (options.vectors == 'separate') {
-            return vectors;
-        }
-        return [sql `(${sql.join(vectors, sql ` || `)})`];
-    }
     function buildPrimaryKey(table) {
         const columns = primaryKeyColumnDefinitions.map((columnDefinition) => getColumn(table, columnDefinition.name));
         return primaryKey({
@@ -112,42 +88,118 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
     const primaryKeyColumnDefinitions = columnDefinitions.filter((columnDefinition) => columnDefinition.reflectionData?.primaryKey == true);
     const skipPrimaryKey = primaryKeyColumnDefinitions.length > 1;
     const columnEntries = columnDefinitions.map((entry) => [entry.name, entry.buildType({ skipPrimaryKey })]);
-    const drizzleSchema = dbSchema.table(tableName, fromEntries(columnEntries), (table) => [
-        ...((primaryKeyColumnDefinitions.length > 1)
-            ? [buildPrimaryKey(table)]
-            : []),
-        ...(columnDefinitions.map((columnDefinition) => {
-            const indexData = columnDefinition.reflectionData?.index;
-            if (isUndefined(indexData)) {
-                return undefined;
-            }
-            return buildIndex(table, indexData, columnDefinition.name);
-        }).filter(isDefined)),
-        ...tableReflectionDatas.flatMap((tableReflectionData) => {
-            return tableReflectionData.foreignKeys?.map((foreignKeyData) => {
-                const foreignTable = getDrizzleTableFromType(foreignKeyData.target(), dbSchema.schemaName);
-                return foreignKey({
-                    name: foreignKeyData.options?.name ?? getForeignKeyName(tableName, foreignKeyData.columns, { naming: foreignKeyData.options?.naming }),
-                    columns: foreignKeyData.columns.map((column) => getColumn(table, column)),
-                    foreignColumns: foreignKeyData.foreignColumns.map((column) => getColumn(foreignTable, column)),
-                });
-            }) ?? [];
-        }),
-        ...tableReflectionDatas.flatMap((tableReflectionData) => tableReflectionData.unique).filter(isDefined).map((data) => {
-            const columns = data.columns?.map((column) => getColumn(table, column));
-            let constraint = unique(data.options?.name ?? getUniqueName(tableName, columns, { naming: data.options?.naming })).on(...columns);
-            if (data.options?.nulls == 'not distinct') {
-                constraint = constraint.nullsNotDistinct();
-            }
-            return constraint;
-        }),
-        ...tableReflectionDatas.flatMap((tableReflectionData) => tableReflectionData.index).filter(isDefined).map((data) => buildIndex(table, data)),
-        ...tableReflectionDatas.flatMap((tableReflectionData) => tableReflectionData.checks).filter(isDefined).map((data) => check(data.name, data.builder(table))),
-    ]);
+    const fullTextSearchColumnEntries = tableReflectionDatas
+        .flatMap((tableReflectionData) => tableReflectionData.fullTextSearch ?? [])
+        .flatMap((ftsData) => getFullTextSearchColumns(ftsData, () => drizzleSchema, (property) => getColumn(drizzleSchema, property)));
+    const drizzleSchema = dbSchema.table(tableName, fromEntries([
+        ...columnEntries,
+        ...fullTextSearchColumnEntries,
+    ]), (drizzleTable) => {
+        const table = drizzleTable;
+        const indexes = tableReflectionDatas.flatMap((tableReflectionData) => tableReflectionData.index).filter(isDefined).map((data) => buildIndex(drizzleTable, data));
+        const fullTextIndexes = tableReflectionDatas.flatMap((tableReflectionData) => tableReflectionData.fullTextSearch ?? []).flatMap((ftsData) => getFullTextSearchIndexes(ftsData, table, (property) => getColumn(drizzleTable, property)));
+        const checks = tableReflectionDatas.flatMap((tableReflectionData) => tableReflectionData.checks).filter(isDefined).map((data) => check(data.name, data.builder(table)));
+        return [
+            ...((primaryKeyColumnDefinitions.length > 1)
+                ? [buildPrimaryKey(drizzleTable)]
+                : []),
+            ...(columnDefinitions.map((columnDefinition) => {
+                const indexData = columnDefinition.reflectionData?.index;
+                if (isUndefined(indexData)) {
+                    return undefined;
+                }
+                return buildIndex(drizzleTable, indexData, columnDefinition.name);
+            }).filter(isDefined)),
+            ...tableReflectionDatas.flatMap((tableReflectionData) => {
+                return tableReflectionData.foreignKeys?.map((foreignKeyData) => {
+                    const foreignTable = getDrizzleTableFromType(foreignKeyData.target(), dbSchema.schemaName);
+                    return foreignKey({
+                        name: foreignKeyData.options?.name ?? getForeignKeyName(tableName, foreignKeyData.columns, { naming: foreignKeyData.options?.naming }),
+                        columns: foreignKeyData.columns.map((column) => getColumn(drizzleTable, column)),
+                        foreignColumns: foreignKeyData.foreignColumns.map((column) => getColumn(foreignTable, column)),
+                    });
+                }) ?? [];
+            }),
+            ...tableReflectionDatas.flatMap((tableReflectionData) => tableReflectionData.unique).filter(isDefined).map((data) => {
+                const columns = data.columns?.map((column) => getColumn(drizzleTable, column));
+                let constraint = unique(data.options?.name ?? getUniqueName(tableName, columns, { naming: data.options?.naming })).on(...columns);
+                if (data.options?.nulls == 'not distinct') {
+                    constraint = constraint.nullsNotDistinct();
+                }
+                return constraint;
+            }),
+            ...indexes,
+            ...fullTextIndexes,
+            ...checks,
+        ];
+    });
     drizzleSchema[columnDefinitionsSymbol] = columnDefinitions;
     drizzleSchema[columnDefinitionsMapSymbol] = columnDefinitionsMap;
     return drizzleSchema;
 }
+function getFullTextSearchColumns(data, tableProvider, columnProvider) {
+    if (isDefined(data.vector)) {
+        const name = `fts_v_${data.name}`;
+        const generationSource = () => {
+            const table = tableProvider();
+            const source = assertDefinedPass(resolveValueOrProvider(data.source ?? data.vector?.rawVectorSource, table), 'Either "source" or "vector.rawVectorSource" must be provided for full-text search vector generation.');
+            const language = resolveValueOrProvider(data.vector?.language ?? 'simple', table);
+            return match(source)
+                .with(P.instanceOf(SQL), (sqlExpression) => sqlExpression)
+                .otherwise((paths) => {
+                const vectors = paths.map((property) => {
+                    const column = columnProvider(property);
+                    const tsVector = toTsVector(language, column);
+                    const weight = data.vector?.weights?.[property];
+                    if (isDefined(weight)) {
+                        return setweight(tsVector, weight);
+                    }
+                    return tsVector;
+                });
+                return sql `(${sql.join(vectors, sql ` || `)})`;
+            });
+        };
+        const column = tsvector(name).generatedAlwaysAs(generationSource);
+        return [[name, column]];
+    }
+    return [];
+}
+function getFullTextSearchIndexes(data, table, columnProvider) {
+    return [
+        ...iif(isDefined(data.vector), () => {
+            const indexName = `fts_${data.name}_bm25`;
+            const textSource = assertDefinedPass(data.source, 'Either "source" or "vector.rawVectorSource" must be provided for full-text search vector generation.');
+            const source = resolveValueOrProvider(textSource, table);
+            const indexExpression = match(source)
+                .with(P.instanceOf(SQL), (sqlExpression) => sqlExpression)
+                .otherwise((paths) => {
+                const columns = paths.map((property) => columnProvider(property));
+                return sql `(${sql.join(columns, sql ` || `)})`;
+            });
+            const bm25Index = index(indexName).using('bm25', indexExpression).with({ key_field: 'id' });
+            return [bm25Index];
+        }, () => []),
+        ...iif(isDefined(data.vector), () => {
+            const columnName = `fts_v_${data.name}`;
+            const indexName = `${columnName}_gin`;
+            const ginIndex = index(indexName).using('gin', columnProvider(columnName)).with({ fastupdate: 'off' });
+            return [ginIndex];
+        }, () => []),
+        ...iif(isDefined(data.trigram), () => {
+            const indexName = `fts_t_${data.name}_gist`;
+            const textSource = assertDefinedPass(data.source, 'Either "source" or "vector.rawVectorSource" must be provided for full-text search vector generation.');
+            const source = resolveValueOrProvider(textSource, table);
+            const indexExpression = match(source)
+                .with(P.instanceOf(SQL), (sqlExpression) => sqlExpression)
+                .otherwise((paths) => {
+                const columns = paths.map((property) => columnProvider(property));
+                return sql `(${sql.join(columns, sql ` || `)})`;
+            });
+            const gistIndex = index(indexName).using('gist', indexExpression).with({ fastupdate: 'off' });
+            return [gistIndex];
+        }, () => []),
+    ];
+}
 function getPostgresColumnEntries(type, dbSchema, tableName, path = new JsonPath({ dollar: false }), prefix = '') {
     const metadata = reflectionRegistry.getMetadata(type);
     assertDefined(metadata, `Type ${type.name} does not have reflection metadata (path: ${path.toString()}).`);

package/orm/server/types.d.ts

@@ -3,8 +3,7 @@ import type { PgColumnBuilder, PgTableWithColumns } from 'drizzle-orm/pg-core';
 import type { CamelCase, ConditionalPick, SnakeCase } from 'type-fest';
 import type { JsonPath } from '../../json-path/json-path.js';
 import type { Record } from '../../schema/index.js';
-import type { UnionToIntersection } from '../../types/index.js';
-import type { Tagged } from '../../types/index.js';
+import type { Tagged, UnionToIntersection } from '../../types/index.js';
 import type { OrmColumnReflectionData } from '../decorators.js';
 import type { EntityType } from '../entity.js';
 import type { ColumnBuilder, EmbeddedConfigTag } from '../types.js';
@@ -32,7 +31,7 @@ export type PgTableFromType<T extends EntityType = EntityType, S extends string
     name: TableName;
     schema: S;
     columns: BuildColumns<TableName, {
-        [P in Exclude<keyof InstanceType<T>, keyof EmbeddedProperties<InstanceType<T>>>]: Column<CamelCase<Extract<P, string>>, InstanceType<T>[P]>;
+        [P in Exclude<Exclude<keyof InstanceType<T>, '__entityMeta__'>, keyof EmbeddedProperties<InstanceType<T>>>]: Column<CamelCase<Extract<P, string>>, InstanceType<T>[P]>;
     } & UnionToIntersection<{
         [P in keyof EmbeddedProperties<InstanceType<T>>]: EmbeddedColumns<InstanceType<T>[P], ColumnPrefix<InstanceType<T>[P]>>;
     }[keyof EmbeddedProperties<InstanceType<T>>]>, 'pg'>;

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.15",
+  "version": "0.93.17",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
   },
   "type": "module",
   "scripts": {
-    "build": "tsc && tsc-alias",
+    "build": "tsc && tsc-alias && npm run copy:orm",
     "build:watch": "concurrently --raw --kill-others npm:tsc:watch npm:tsc-alias:watch",
     "build:production": "rm -rf dist && npm run build && npm run build:production:copy-files",
     "build:production:copy-files": "cp package.json eslint.config.js tsconfig.server.json dist/ && cp tsconfig.base.json dist/tsconfig.json && npm run copy:orm",
@@ -131,12 +131,12 @@
     "luxon": "^3.7",
     "reflect-metadata": "^0.2",
     "rxjs": "^7.8",
-    "ts-pattern": "^5.8",
+    "ts-pattern": "^5.9",
     "type-fest": "^5.1"
   },
   "peerDependencies": {
     "@google-cloud/storage": "^7.17",
-    "@google/genai": "^1.26",
+    "@google/genai": "^1.27",
     "@tstdl/angular": "^0.93",
     "@zxcvbn-ts/core": "^3.0",
     "@zxcvbn-ts/language-common": "^3.0",

package/test/drizzle/0002_nice_squadron_supreme.sql

@@ -0,0 +1 @@
+DROP INDEX "test"."test_title_content_tags_idx";

package/test/drizzle/0003_serious_mockingbird.sql

@@ -0,0 +1 @@
+ALTER TABLE "test"."test" ADD COLUMN "ftsv_asd" "tsvector" GENERATED ALWAYS AS ((setweight(to_tsvector('simple', "test"."test"."title"), 'A') || setweight(to_tsvector('simple', "test"."test"."content"), 'B') || setweight(to_tsvector('simple', "test"."test"."tags"), 'C'))) STORED;

package/test/drizzle/0004_complete_pixie.sql

@@ -0,0 +1 @@
+CREATE INDEX "ftsv_asd_gin" ON "test"."test" USING gin ("ftsv_asd");

package/test/drizzle/0005_bumpy_sabra.sql

@@ -0,0 +1 @@
+CREATE INDEX "ftst_asd_gist" ON "test"."test" USING gist (("title" || "content" || "tags"));

package/test/drizzle/0006_overrated_post.sql

@@ -0,0 +1,6 @@
+DROP INDEX "test"."ftsv_asd_gin";--> statement-breakpoint
+DROP INDEX "test"."ftst_asd_gist";--> statement-breakpoint
+ALTER TABLE "test"."test" ADD COLUMN "fts_v_asd" "tsvector" GENERATED ALWAYS AS ((setweight(to_tsvector('simple', "test"."test"."title"), 'A') || setweight(to_tsvector('simple', "test"."test"."content"), 'B') || setweight(to_tsvector('simple', "test"."test"."tags"), 'C'))) STORED;--> statement-breakpoint
+CREATE INDEX "fts_v_asd_gin" ON "test"."test" USING gin ("fts_v_asd");--> statement-breakpoint
+CREATE INDEX "fts_t_asd_gist" ON "test"."test" USING gist (("title" || "content" || "tags"));--> statement-breakpoint
+ALTER TABLE "test"."test" DROP COLUMN "ftsv_asd";

package/test/drizzle/meta/0002_snapshot.json

@@ -0,0 +1,63 @@
+{
+  "id": "c8eced2f-44d3-46b3-aafa-e8a775549cd0",
+  "prevId": "3949ca77-11a4-4ca4-a404-1529e02d058c",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "test.test": {
+      "name": "test",
+      "schema": "test",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "tags": {
+          "name": "tags",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "language": {
+          "name": "language",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}

package/test/drizzle/meta/0003_snapshot.json

@@ -0,0 +1,73 @@
+{
+  "id": "febb0102-cd99-43ee-8458-f25dc50e5264",
+  "prevId": "c8eced2f-44d3-46b3-aafa-e8a775549cd0",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "test.test": {
+      "name": "test",
+      "schema": "test",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "tags": {
+          "name": "tags",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "language": {
+          "name": "language",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ftsv_asd": {
+          "name": "ftsv_asd",
+          "type": "tsvector",
+          "primaryKey": false,
+          "notNull": false,
+          "generated": {
+            "as": "(setweight(to_tsvector('simple', \"test\".\"test\".\"title\"), 'A') || setweight(to_tsvector('simple', \"test\".\"test\".\"content\"), 'B') || setweight(to_tsvector('simple', \"test\".\"test\".\"tags\"), 'C'))",
+            "type": "stored"
+          }
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}

package/test/drizzle/meta/0004_snapshot.json

@@ -0,0 +1,89 @@
+{
+  "id": "40cebc5a-7b84-40ff-ba11-c878018e6488",
+  "prevId": "febb0102-cd99-43ee-8458-f25dc50e5264",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "test.test": {
+      "name": "test",
+      "schema": "test",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "tags": {
+          "name": "tags",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "language": {
+          "name": "language",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ftsv_asd": {
+          "name": "ftsv_asd",
+          "type": "tsvector",
+          "primaryKey": false,
+          "notNull": false,
+          "generated": {
+            "as": "(setweight(to_tsvector('simple', \"test\".\"test\".\"title\"), 'A') || setweight(to_tsvector('simple', \"test\".\"test\".\"content\"), 'B') || setweight(to_tsvector('simple', \"test\".\"test\".\"tags\"), 'C'))",
+            "type": "stored"
+          }
+        }
+      },
+      "indexes": {
+        "ftsv_asd_gin": {
+          "name": "ftsv_asd_gin",
+          "columns": [
+            {
+              "expression": "ftsv_asd",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}

package/test/drizzle/meta/0005_snapshot.json

@@ -0,0 +1,104 @@
+{
+  "id": "11b20d13-8277-4ab5-bf78-998c6d7816d4",
+  "prevId": "40cebc5a-7b84-40ff-ba11-c878018e6488",
+  "version": "7",
+  "dialect": "postgresql",
+  "tables": {
+    "test.test": {
+      "name": "test",
+      "schema": "test",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "uuid",
+          "primaryKey": true,
+          "notNull": true,
+          "default": "gen_random_uuid()"
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "tags": {
+          "name": "tags",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "language": {
+          "name": "language",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true
+        },
+        "ftsv_asd": {
+          "name": "ftsv_asd",
+          "type": "tsvector",
+          "primaryKey": false,
+          "notNull": false,
+          "generated": {
+            "as": "(setweight(to_tsvector('simple', \"test\".\"test\".\"title\"), 'A') || setweight(to_tsvector('simple', \"test\".\"test\".\"content\"), 'B') || setweight(to_tsvector('simple', \"test\".\"test\".\"tags\"), 'C'))",
+            "type": "stored"
+          }
+        }
+      },
+      "indexes": {
+        "ftsv_asd_gin": {
+          "name": "ftsv_asd_gin",
+          "columns": [
+            {
+              "expression": "ftsv_asd",
+              "isExpression": false,
+              "asc": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gin",
+          "with": {}
+        },
+        "ftst_asd_gist": {
+          "name": "ftst_asd_gist",
+          "columns": [
+            {
+              "expression": "(\"title\" || \"content\" || \"tags\")",
+              "asc": true,
+              "isExpression": true,
+              "nulls": "last"
+            }
+          ],
+          "isUnique": false,
+          "concurrently": false,
+          "method": "gist",
+          "with": {}
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "policies": {},
+      "checkConstraints": {},
+      "isRLSEnabled": false
+    }
+  },
+  "enums": {},
+  "schemas": {},
+  "sequences": {},
+  "roles": {},
+  "policies": {},
+  "views": {},
+  "_meta": {
+    "columns": {},
+    "schemas": {},
+    "tables": {}
+  }
+}