@yandjin-mikro-orm/postgresql 6.1.4-rc-sti-changes-1

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@yandjin-mikro-orm/postgresql",
+  "version": "6.1.4-rc-sti-changes-1",
+  "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
+  "main": "index.js",
+  "module": "index.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": {
+        "types": "./index.d.ts",
+        "default": "./index.mjs"
+      },
+      "require": "./index.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/mikro-orm/mikro-orm.git"
+  },
+  "keywords": [
+    "orm",
+    "mongo",
+    "mongodb",
+    "mysql",
+    "mariadb",
+    "postgresql",
+    "sqlite",
+    "sqlite3",
+    "ts",
+    "typescript",
+    "js",
+    "javascript",
+    "entity",
+    "ddd",
+    "mikro-orm",
+    "unit-of-work",
+    "data-mapper",
+    "identity-map"
+  ],
+  "author": "Martin Adámek",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/mikro-orm/mikro-orm/issues"
+  },
+  "homepage": "https://mikro-orm.io",
+  "engines": {
+    "node": ">= 18.12.0"
+  },
+  "scripts": {
+    "build": "yarn clean && yarn compile && yarn copy && yarn run -T gen-esm-wrapper index.js index.mjs",
+    "clean": "yarn run -T rimraf ./dist",
+    "compile": "yarn run -T tsc -p tsconfig.build.json",
+    "copy": "node ../../scripts/copy.mjs"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@yandjin-mikro-orm/knex": "6.1.4-rc-sti-changes-1",
+    "pg": "8.12.0",
+    "postgres-array": "3.0.2",
+    "postgres-date": "2.1.0",
+    "postgres-interval": "4.0.2"
+  },
+  "devDependencies": {
+    "@yandjin-mikro-orm/core": "^6.1.4-rc-sti-changes-1"
+  },
+  "peerDependencies": {
+    "@yandjin-mikro-orm/core": "^6.0.0"
+  }
+}

package/types/FullTextType.d.ts

@@ -0,0 +1,14 @@
+import { Type, type TransformContext, type RawQueryFragment } from "@yandjin-mikro-orm/core";
+import type { PostgreSqlPlatform } from "../PostgreSqlPlatform";
+type FullTextWeight = "A" | "B" | "C" | "D";
+export type WeightedFullTextValue = {
+    [K in FullTextWeight]?: string | null;
+};
+export declare class FullTextType extends Type<string | WeightedFullTextValue, string | null | RawQueryFragment> {
+    regconfig: string;
+    constructor(regconfig?: string);
+    compareAsType(): string;
+    getColumnType(): string;
+    convertToDatabaseValue(value: string | WeightedFullTextValue, platform: PostgreSqlPlatform, context?: TransformContext | boolean): string | null | RawQueryFragment;
+}
+export {};

package/types/FullTextType.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FullTextType = void 0;
+const core_1 = require("@yandjin-mikro-orm/core");
+class FullTextType extends core_1.Type {
+    regconfig;
+    constructor(regconfig = "simple") {
+        super();
+        this.regconfig = regconfig;
+    }
+    compareAsType() {
+        return "string";
+    }
+    getColumnType() {
+        return "tsvector";
+    }
+    // Use convertToDatabaseValue to prepare insert queries as this method has
+    // access to the raw JS value. Return Knex#raw to prevent QueryBuilderHelper#mapData
+    // from sanitizing the returned chaing of SQL functions.
+    convertToDatabaseValue(value, platform, context) {
+        // Don't convert to values from select queries to the to_tsvector notation
+        // these should be compared as string using a special oparator or function
+        // this behaviour is defined in Platform#getFullTextWhereClause.
+        // This is always a string.
+        if (typeof context === "object" && context.fromQuery) {
+            return value;
+        }
+        // Null values should not be processed
+        if (!value) {
+            return null;
+        }
+        // the object from that looks like { A: 'test data', B: 'test data2' ... }
+        // must be converted to
+        // setweight(to_tsvector(regconfig, value), A) || setweight(to_tsvector(regconfig, value), B)... etc
+        // use Knex#raw to do binding of the values sanitization of the boundvalues
+        // as we return a raw string which should not be sanitzed anymore
+        if (typeof value === "object") {
+            const bindings = [];
+            const sqlParts = [];
+            for (const [weight, data] of Object.entries(value)) {
+                // Check whether the weight is valid according to Postgres,
+                // Postgres allows the weight to be upper and lowercase.
+                if (!["A", "B", "C", "D"].includes(weight.toUpperCase())) {
+                    throw new Error("Weight should be one of A, B, C, D.");
+                }
+                // Ignore all values that are not a string
+                if (typeof data === "string") {
+                    sqlParts.push("setweight(to_tsvector(?, ?), ?)");
+                    bindings.push(this.regconfig, data, weight);
+                }
+            }
+            // Return null if the object has no valid strings
+            if (sqlParts.length === 0) {
+                return null;
+            }
+            // Join all the `setweight` parts using the PostgreSQL tsvector `||` concatenation operator
+            return (0, core_1.raw)(sqlParts.join(" || "), bindings);
+        }
+        // if it's not an object, it is expected to be string which does not have to be wrapped in setweight.
+        return (0, core_1.raw)("to_tsvector(?, ?)", [this.regconfig, value]);
+    }
+}
+exports.FullTextType = FullTextType;

package/types/index.d.ts

@@ -0,0 +1 @@
+export * from './FullTextType';

package/types/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./FullTextType"), exports);