ts-prorm-orm 1.1.0

package/dist/nosql/virtuoso/index.js

@@ -0,0 +1,169 @@
+"use strict";
+/**
+ * OpenLink Virtuoso store implementation.
+ *
+ * Virtuoso is a multi-model server whose RDF triplestore is queried over the
+ * SPARQL 1.1 Protocol via a single combined HTTP endpoint (`/sparql`) used for
+ * both queries and updates (dispatched by request content-type). There is no
+ * SQL-shaped RDF surface here, so it implements the minimal `NoSqlStore`
+ * marker interface (`src/nosql/store.ts`) rather than the SQL `Dialect`
+ * interface.
+ *
+ * ## No canonical driver - HTTP over `fetch`
+ *
+ * Virtuoso's SPARQL endpoint is just an HTTP/SPARQL API. This store talks to
+ * the server with the global `fetch`. For tests (and for callers who want
+ * their own transport) an alternative client can be injected via
+ * `VirtuosoStoreOptions.client`; when omitted, a tiny internal client over
+ * `fetch` + `endpoint` is built at connect time.
+ *
+ * ## Surface
+ *
+ * - `query(sparql)`  -> POST to `/sparql`, returns bindings
+ * - `update(sparql)` -> POST to `/sparql`
+ * - `ask(sparql)`    -> POST an ASK query, returns the boolean
+ * - `add(triples)`   -> `INSERT DATA { ... }` update
+ * - `drop(graph?)`   -> `DROP GRAPH <g>` / `DROP ALL` update
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VirtuosoStore = exports.DEFAULT_VIRTUOSO_SPARQL_PATH = exports.DEFAULT_VIRTUOSO_ENDPOINT = void 0;
+exports.createFetchClient = createFetchClient;
+const errors_1 = require("../../errors");
+/** Default Virtuoso base URL. */
+exports.DEFAULT_VIRTUOSO_ENDPOINT = 'http://localhost:8890';
+/** SPARQL endpoint path. */
+exports.DEFAULT_VIRTUOSO_SPARQL_PATH = '/sparql';
+/** Build a `fetch`-backed SPARQL client for the given endpoint. */
+function createFetchClient(endpoint, headers) {
+    const base = endpoint.endsWith('/') ? endpoint : `${endpoint}/`;
+    const buildUrl = (path) => new URL(path.replace(/^\//, ''), base).toString();
+    return {
+        async query(path, sparql) {
+            const res = await fetch(buildUrl(path), {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/sparql-query',
+                    Accept: 'application/sparql-results+json',
+                    ...(headers ?? {}),
+                },
+                body: sparql,
+            });
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status} ${res.statusText}`);
+            return res.json();
+        },
+        async update(path, sparql) {
+            const res = await fetch(buildUrl(path), {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/sparql-update', ...(headers ?? {}) },
+                body: sparql,
+            });
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status} ${res.statusText}`);
+            const text = await res.text();
+            return text || undefined;
+        },
+    };
+}
+/**
+ * `VirtuosoStore` wraps Virtuoso's `/sparql` endpoint behind the `NoSqlStore`
+ * lifecycle.
+ */
+class VirtuosoStore {
+    constructor(options = {}) {
+        this.name = 'virtuoso';
+        this.library = 'fetch';
+        this.client = null;
+        this.connected = false;
+        this.endpoint = options.endpoint ?? exports.DEFAULT_VIRTUOSO_ENDPOINT;
+        this.sparqlPath = options.sparqlPath ?? exports.DEFAULT_VIRTUOSO_SPARQL_PATH;
+        this.injectedClient = options.client;
+        this.headers = options.headers;
+    }
+    /** SPARQL query endpoint path. */
+    get queryPath() {
+        return this.sparqlPath;
+    }
+    /** SPARQL update endpoint path (same endpoint). */
+    get updatePath() {
+        return this.sparqlPath;
+    }
+    // ---------------------------------------------------------------------
+    // Connection lifecycle
+    // ---------------------------------------------------------------------
+    async connect() {
+        if (this.connected && this.client)
+            return;
+        this.client = this.injectedClient ?? createFetchClient(this.endpoint, this.headers);
+        this.connected = true;
+    }
+    async disconnect() {
+        this.client = null;
+        this.connected = false;
+    }
+    isConnected() {
+        return this.connected && this.client !== null;
+    }
+    /** Returns the underlying (internal or injected) SPARQL HTTP client. */
+    getClient() {
+        return this.requireClient();
+    }
+    requireClient() {
+        if (!this.client) {
+            throw new errors_1.ConnectionError('Not connected to Virtuoso', {
+                database: 'virtuoso',
+                host: this.endpoint,
+            });
+        }
+        return this.client;
+    }
+    // ---------------------------------------------------------------------
+    // SPARQL surface
+    // ---------------------------------------------------------------------
+    /** Runs a SPARQL SELECT/CONSTRUCT query; returns the result bindings. */
+    async query(sparql) {
+        const client = this.requireClient();
+        try {
+            const body = await client.query(this.queryPath, sparql);
+            return body?.results?.bindings ?? [];
+        }
+        catch (err) {
+            const parent = err instanceof Error ? err : new Error(String(err));
+            throw errors_1.DatabaseError.from(parent, { message: `Virtuoso query failed: ${parent.message}`, sql: sparql });
+        }
+    }
+    /** Runs a SPARQL ASK query; returns the boolean answer. */
+    async ask(sparql) {
+        const client = this.requireClient();
+        try {
+            const body = await client.query(this.queryPath, sparql);
+            return Boolean(body?.boolean);
+        }
+        catch (err) {
+            const parent = err instanceof Error ? err : new Error(String(err));
+            throw errors_1.DatabaseError.from(parent, { message: `Virtuoso ask failed: ${parent.message}`, sql: sparql });
+        }
+    }
+    /** Runs a SPARQL UPDATE (INSERT/DELETE/DROP/...). */
+    async update(sparql) {
+        const client = this.requireClient();
+        try {
+            return await client.update(this.updatePath, sparql);
+        }
+        catch (err) {
+            const parent = err instanceof Error ? err : new Error(String(err));
+            throw errors_1.DatabaseError.from(parent, { message: `Virtuoso update failed: ${parent.message}`, sql: sparql });
+        }
+    }
+    /** Inserts triples via `INSERT DATA { ... }`. Accepts a triple string or array. */
+    async add(triples, graph) {
+        const body = Array.isArray(triples) ? triples.join('\n') : triples;
+        const inner = graph ? `GRAPH <${graph}> { ${body} }` : body;
+        return this.update(`INSERT DATA { ${inner} }`);
+    }
+    /** Drops a named graph, or all graphs when no graph is given. */
+    async drop(graph) {
+        return this.update(graph ? `DROP GRAPH <${graph}>` : 'DROP ALL');
+    }
+}
+exports.VirtuosoStore = VirtuosoStore;

package/dist/nosql/weaviate/index.js

@@ -0,0 +1,276 @@
+"use strict";
+/**
+ * Weaviate store implementation.
+ *
+ * Weaviate is a vector database: collections ("classes") hold objects (a
+ * UUID, a JSON `properties` bag, and one or more dense vectors), and the
+ * primary query shape is "find the objects whose vector is closest to this
+ * vector/text" (optionally constrained by a structured filter), plus plain
+ * property-filtered fetches - not SQL, not `WHERE`, not joins. It does not
+ * fit the SQL-shaped `Dialect` interface used by the SQL dialects in this
+ * repo, so this class implements the minimal `NoSqlStore` marker interface
+ * and exposes Weaviate's real collection/object/query operations instead of
+ * forcing them into a `query(sql)` shape.
+ *
+ * Uses the official `weaviate-client` (v3) driver, which exposes a
+ * collection-oriented fluent API (`client.collections.get(name).data.*` /
+ * `.query.*`) built on gRPC, rather than the older `weaviate-ts-client` (v2)
+ * REST/GraphQL client.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WeaviateStore = void 0;
+const weaviate_client_1 = __importDefault(require("weaviate-client"));
+const errors_1 = require("../../errors");
+function wrapConnectionError(err, host) {
+    const parent = err instanceof Error ? err : new Error(String(err));
+    const message = /ECONNREFUSED|fetch failed|WeaviateConnectionError/i.test(parent.message)
+        ? 'Connection refused'
+        : `Unable to connect to Weaviate: ${parent.message}`;
+    return new errors_1.ConnectionError(message, { parent, database: 'weaviate', host });
+}
+function wrapDatabaseError(err, message) {
+    const parent = err instanceof Error ? err : new Error(String(err));
+    // Keep the `action` context (e.g. "Weaviate NEAR VECTOR failed") but don't
+    // discard the real underlying Weaviate error text (e.g. "collection
+    // 'Article' not found") - append it so callers inspecting `err.message`
+    // still see what actually went wrong.
+    const combined = message ? `${message}: ${parent.message}` : parent.message;
+    return errors_1.DatabaseError.from(parent, { message: combined });
+}
+/**
+ * `WeaviateStore` wraps a `weaviate-client` (v3) `WeaviateClient` and exposes
+ * Weaviate's collection management, object insert/query/update/delete, and
+ * near-vector/near-text similarity search as a typed, promise-based API.
+ */
+class WeaviateStore {
+    constructor(options = {}) {
+        this.name = 'weaviate';
+        this.library = 'weaviate-client';
+        this.client = null;
+        this.connected = false;
+        this.options = options;
+    }
+    // ---------------------------------------------------------------------
+    // Connection lifecycle
+    // ---------------------------------------------------------------------
+    async connect() {
+        if (this.connected && this.client) {
+            return;
+        }
+        try {
+            const client = this.options.clusterURL
+                ? await weaviate_client_1.default.connectToWeaviateCloud(this.options.clusterURL, this.options)
+                : await weaviate_client_1.default.connectToLocal(this.options);
+            // Unlike ioredis, `connectToLocal`/`connectToWeaviateCloud` already
+            // perform init checks (readiness/liveness) by default and throw if
+            // they fail, so there's no separate "verify the connection" step
+            // needed here - a resolved promise means the client is usable.
+            this.client = client;
+            this.connected = true;
+        }
+        catch (err) {
+            this.client = null;
+            this.connected = false;
+            throw wrapConnectionError(err, this.hostForErrors());
+        }
+    }
+    hostForErrors() {
+        if (this.options.clusterURL) {
+            return this.options.clusterURL;
+        }
+        const local = this.options;
+        return local.host;
+    }
+    async disconnect() {
+        if (this.client) {
+            await this.client.close();
+            this.client = null;
+        }
+        this.connected = false;
+    }
+    isConnected() {
+        return this.connected && this.client !== null;
+    }
+    /** Returns the underlying `weaviate-client` `WeaviateClient` for anything not wrapped here. */
+    getClient() {
+        return this.requireClient();
+    }
+    requireClient() {
+        if (!this.client) {
+            throw new errors_1.ConnectionError('Not connected to Weaviate', { database: 'weaviate' });
+        }
+        return this.client;
+    }
+    async exec(fn, action) {
+        const client = this.requireClient();
+        try {
+            return await fn(client);
+        }
+        catch (err) {
+            throw wrapDatabaseError(err, `Weaviate ${action} failed`);
+        }
+    }
+    collection(collectionName) {
+        return this.requireClient().collections.get(collectionName);
+    }
+    /**
+     * Build a `FilterValue` (see `nearVector()`/`fetchObjects()`/`deleteMany()`'s
+     * `filters` option) against a collection's schema, e.g.
+     * `store.filter('Article').byProperty('title').equal('Hello')`.
+     */
+    filter(collectionName) {
+        return this.collection(collectionName).filter;
+    }
+    // ---------------------------------------------------------------------
+    // Collection (class) management
+    // ---------------------------------------------------------------------
+    /**
+     * Create a new collection ("class"). `properties` declares the object
+     * schema (name/dataType/indexing per field); `vectorizer` configures how
+     * vectors are produced - pass `weaviate.configure.vectorizer.none()` for
+     * bring-your-own vectors, or a module config like
+     * `weaviate.configure.vectorizer.text2VecOpenAI()` to have Weaviate call
+     * out to an embedding provider (which requires the corresponding API key
+     * in `headers`, e.g. `X-OpenAI-Api-Key`, at connect time).
+     */
+    async createCollection(collectionName, properties = [], vectorizer, options = {}) {
+        return this.exec(async (c) => {
+            const created = await c.collections.create({
+                name: collectionName,
+                properties,
+                vectorizers: vectorizer,
+                ...options,
+            });
+            return created.config.get();
+        }, 'CREATE COLLECTION');
+    }
+    /** Delete a collection and all of its objects. */
+    async deleteCollection(collectionName) {
+        return this.exec((c) => c.collections.delete(collectionName), 'DELETE COLLECTION');
+    }
+    /** List every collection's configuration. */
+    async listCollections() {
+        return this.exec((c) => c.collections.listAll(), 'LIST COLLECTIONS');
+    }
+    /** Whether a collection with this name exists. */
+    async collectionExists(collectionName) {
+        return this.exec((c) => c.collections.exists(collectionName), 'COLLECTION EXISTS');
+    }
+    /** Detailed schema/config for one collection (properties, vectorizer, replication, etc). */
+    async getCollection(collectionName) {
+        return this.exec((c) => c.collections.export(collectionName), 'GET COLLECTION');
+    }
+    // ---------------------------------------------------------------------
+    // Object insert
+    // ---------------------------------------------------------------------
+    /**
+     * Insert a single object. `object.vector` (renamed `vectors` on the wire)
+     * may be omitted entirely for collections with a server-side vectorizer
+     * module, or supplied explicitly (a plain array, or a `{ name: vector }`
+     * map for named-vector collections) for `none`/self-provided vectorizers.
+     * Returns the object's UUID (generated if `object.id` wasn't given).
+     */
+    async insertObject(collectionName, object = {}) {
+        return this.exec((c) => c.collections.get(collectionName).data.insert(object), 'INSERT');
+    }
+    /**
+     * Insert multiple objects in a single request (no client-side batching -
+     * all `objects` are sent together). Per-object failures are reported in
+     * the returned `errors`/`hasErrors` rather than rejecting the whole call;
+     * check `hasErrors` to detect partial failures.
+     */
+    async insertMany(collectionName, objects) {
+        return this.exec((c) => c.collections.get(collectionName).data.insertMany(objects), 'INSERT MANY');
+    }
+    // ---------------------------------------------------------------------
+    // Query / similarity search
+    // ---------------------------------------------------------------------
+    /** Find the objects whose vector is closest to `vector`, optionally constrained by `options.filters`. */
+    async nearVector(collectionName, vector, options = {}) {
+        return this.exec((c) => c.collections.get(collectionName).query.nearVector(vector, options), 'NEAR VECTOR');
+    }
+    /**
+     * Find the objects whose vector is closest to the vectorized form of
+     * `query` (a single string, or multiple strings averaged together).
+     * Requires the collection to have a text vectorizer module configured
+     * (this is not a keyword/BM25 search - use `getClient()` for that).
+     */
+    async nearText(collectionName, query, options = {}) {
+        return this.exec((c) => c.collections.get(collectionName).query.nearText(query, options), 'NEAR TEXT');
+    }
+    /**
+     * Fetch objects without a similarity search - the vector-store analogue
+     * of `SELECT ... WHERE ...`. Supports `limit`/`offset`/cursor-based
+     * pagination (`after`), `filters`, and `returnProperties` to select which
+     * fields come back.
+     */
+    async fetchObjects(collectionName, options = {}) {
+        return this.exec((c) => c.collections.get(collectionName).query.fetchObjects(options), 'FETCH OBJECTS');
+    }
+    /** Fetch a single object by its UUID. Returns `null` if no object with that ID exists. */
+    async fetchObjectById(collectionName, id, options = {}) {
+        return this.exec((c) => c.collections.get(collectionName).query.fetchObjectById(id, options), 'FETCH OBJECT BY ID');
+    }
+    // ---------------------------------------------------------------------
+    // Update / replace
+    // ---------------------------------------------------------------------
+    /**
+     * Partially update an object (`PATCH` semantics) - only the fields in
+     * `fields.properties`/`fields.vectors` are changed; everything else on
+     * the object is left as-is.
+     */
+    async updateObject(collectionName, id, fields) {
+        return this.exec((c) => c.collections.get(collectionName).data.update({ id, ...fields }), 'UPDATE');
+    }
+    /**
+     * Fully replace an object (`PUT` semantics) - any property not present in
+     * `fields.properties` is cleared, unlike `updateObject()`.
+     */
+    async replaceObject(collectionName, id, fields) {
+        return this.exec((c) => c.collections.get(collectionName).data.replace({ id, ...fields }), 'REPLACE');
+    }
+    // ---------------------------------------------------------------------
+    // Delete
+    // ---------------------------------------------------------------------
+    /** Whether an object with this UUID exists in the collection. */
+    async objectExists(collectionName, id) {
+        return this.exec((c) => c.collections.get(collectionName).data.exists(id), 'OBJECT EXISTS');
+    }
+    /**
+     * Delete a single object by its UUID. Returns `true` if an object was
+     * actually deleted.
+     *
+     * The real `weaviate-client` `data.deleteById()` issues a REST `DELETE`
+     * and resolves `true` unconditionally (Weaviate's `DELETE
+     * /objects/{id}` returns success whether or not an object with that id
+     * existed) - it does not itself report whether anything was deleted.
+     * Check existence first so the documented "returns whether something
+     * was actually deleted" contract holds against the real driver, not
+     * just the test mock (whose `Map.delete()` happens to return that for
+     * free).
+     */
+    async deleteObject(collectionName, id) {
+        return this.exec(async (c) => {
+            const collection = c.collections.get(collectionName);
+            const existed = await collection.data.exists(id);
+            if (!existed) {
+                return false;
+            }
+            await collection.data.deleteById(id);
+            return true;
+        }, 'DELETE');
+    }
+    /**
+     * Delete every object matching `where` (build one with `filter()`). Pass
+     * `{ verbose: true }` to get back the per-object outcome in
+     * `result.objects`; otherwise only the aggregate counts are populated.
+     */
+    async deleteMany(collectionName, where, options = {}) {
+        return this.exec((c) => c.collections.get(collectionName).data.deleteMany(where, options), 'DELETE MANY');
+    }
+}
+exports.WeaviateStore = WeaviateStore;
+exports.default = WeaviateStore;

package/dist/operators/index.js

@@ -0,0 +1,108 @@
+"use strict";
+/**
+ * Operators module - re-exports all operators and helper functions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.endsWith = exports.notStartsWith = exports.startsWith = exports.arrayAll = exports.arrayAny = exports.arrayOverlaps = exports.arrayContainedBy = exports.arrayContains = exports.jsonPathQuery = exports.jsonPathExists = exports.jsonDeletePath = exports.jsonDelete = exports.jsonConcat = exports.jsonHasKey = exports.jsonContains = exports.jsonKey = exports.json = exports.overlap = exports.contains = exports.notExists = exports.exists = exports.isNotNull = exports.isNull = exports.notBetween = exports.between = exports.notIn = exports.inOp = exports.notIRegexp = exports.iRegexp = exports.notRegexp = exports.regexp = exports.notILike = exports.iLike = exports.notLike = exports.like = exports.lte = exports.lt = exports.gte = exports.gt = exports.ne = exports.eq = exports.not = exports.or = exports.and = exports.where = exports.operatorToWhereKey = exports.getOperatorString = exports.isOperator = exports.Operators = exports.Op = void 0;
+exports.isOrderExpression = exports.random = exports.desc = exports.asc = exports.phraseToTsquery = exports.plainToTsquery = exports.toTsquery = exports.toTsvector = exports.matchFulltext = exports.matchAgainst = exports.Cast = exports.isConvExpression = exports.isExtractExpression = exports.isCastExpression = exports.conv = exports.extract = exports.cast = exports.isRawLiteral = exports.isLiteralExpression = exports.isColExpression = exports.isFnExpression = exports.literalExpr = exports.literal = exports.col = exports.fn = exports.all = exports.any = exports.notSubstring = exports.substring = exports.notEndsWith = void 0;
+// Re-export all operators and symbols
+var operators_1 = require("../operators");
+Object.defineProperty(exports, "Op", { enumerable: true, get: function () { return operators_1.Op; } });
+Object.defineProperty(exports, "Operators", { enumerable: true, get: function () { return operators_1.Operators; } });
+Object.defineProperty(exports, "isOperator", { enumerable: true, get: function () { return operators_1.isOperator; } });
+Object.defineProperty(exports, "getOperatorString", { enumerable: true, get: function () { return operators_1.getOperatorString; } });
+Object.defineProperty(exports, "operatorToWhereKey", { enumerable: true, get: function () { return operators_1.operatorToWhereKey; } });
+// Re-export helper functions
+var operators_2 = require("../operators");
+// Core where helpers
+Object.defineProperty(exports, "where", { enumerable: true, get: function () { return operators_2.where; } });
+Object.defineProperty(exports, "and", { enumerable: true, get: function () { return operators_2.and; } });
+Object.defineProperty(exports, "or", { enumerable: true, get: function () { return operators_2.or; } });
+Object.defineProperty(exports, "not", { enumerable: true, get: function () { return operators_2.not; } });
+// Comparison helpers
+Object.defineProperty(exports, "eq", { enumerable: true, get: function () { return operators_2.eq; } });
+Object.defineProperty(exports, "ne", { enumerable: true, get: function () { return operators_2.ne; } });
+Object.defineProperty(exports, "gt", { enumerable: true, get: function () { return operators_2.gt; } });
+Object.defineProperty(exports, "gte", { enumerable: true, get: function () { return operators_2.gte; } });
+Object.defineProperty(exports, "lt", { enumerable: true, get: function () { return operators_2.lt; } });
+Object.defineProperty(exports, "lte", { enumerable: true, get: function () { return operators_2.lte; } });
+// Like operators
+Object.defineProperty(exports, "like", { enumerable: true, get: function () { return operators_2.like; } });
+Object.defineProperty(exports, "notLike", { enumerable: true, get: function () { return operators_2.notLike; } });
+Object.defineProperty(exports, "iLike", { enumerable: true, get: function () { return operators_2.iLike; } });
+Object.defineProperty(exports, "notILike", { enumerable: true, get: function () { return operators_2.notILike; } });
+// Regexp operators
+Object.defineProperty(exports, "regexp", { enumerable: true, get: function () { return operators_2.regexp; } });
+Object.defineProperty(exports, "notRegexp", { enumerable: true, get: function () { return operators_2.notRegexp; } });
+Object.defineProperty(exports, "iRegexp", { enumerable: true, get: function () { return operators_2.iRegexp; } });
+Object.defineProperty(exports, "notIRegexp", { enumerable: true, get: function () { return operators_2.notIRegexp; } });
+// Array/in operators
+Object.defineProperty(exports, "inOp", { enumerable: true, get: function () { return operators_2.in; } });
+Object.defineProperty(exports, "notIn", { enumerable: true, get: function () { return operators_2.notIn; } });
+Object.defineProperty(exports, "between", { enumerable: true, get: function () { return operators_2.between; } });
+Object.defineProperty(exports, "notBetween", { enumerable: true, get: function () { return operators_2.notBetween; } });
+// Null operators
+Object.defineProperty(exports, "isNull", { enumerable: true, get: function () { return operators_2.isNull; } });
+Object.defineProperty(exports, "isNotNull", { enumerable: true, get: function () { return operators_2.isNotNull; } });
+// Exists operators for anti-joins
+Object.defineProperty(exports, "exists", { enumerable: true, get: function () { return operators_2.exists; } });
+Object.defineProperty(exports, "notExists", { enumerable: true, get: function () { return operators_2.notExists; } });
+// JSON/Array operators
+Object.defineProperty(exports, "contains", { enumerable: true, get: function () { return operators_2.contains; } });
+Object.defineProperty(exports, "overlap", { enumerable: true, get: function () { return operators_2.overlap; } });
+Object.defineProperty(exports, "json", { enumerable: true, get: function () { return operators_2.json; } });
+Object.defineProperty(exports, "jsonKey", { enumerable: true, get: function () { return operators_2.jsonKey; } });
+Object.defineProperty(exports, "jsonContains", { enumerable: true, get: function () { return operators_2.jsonContains; } });
+Object.defineProperty(exports, "jsonHasKey", { enumerable: true, get: function () { return operators_2.jsonHasKey; } });
+Object.defineProperty(exports, "jsonConcat", { enumerable: true, get: function () { return operators_2.jsonConcat; } });
+Object.defineProperty(exports, "jsonDelete", { enumerable: true, get: function () { return operators_2.jsonDelete; } });
+Object.defineProperty(exports, "jsonDeletePath", { enumerable: true, get: function () { return operators_2.jsonDeletePath; } });
+Object.defineProperty(exports, "jsonPathExists", { enumerable: true, get: function () { return operators_2.jsonPathExists; } });
+Object.defineProperty(exports, "jsonPathQuery", { enumerable: true, get: function () { return operators_2.jsonPathQuery; } });
+// PostgreSQL Array operators
+Object.defineProperty(exports, "arrayContains", { enumerable: true, get: function () { return operators_2.arrayContains; } });
+Object.defineProperty(exports, "arrayContainedBy", { enumerable: true, get: function () { return operators_2.arrayContainedBy; } });
+Object.defineProperty(exports, "arrayOverlaps", { enumerable: true, get: function () { return operators_2.arrayOverlaps; } });
+Object.defineProperty(exports, "arrayAny", { enumerable: true, get: function () { return operators_2.arrayAny; } });
+Object.defineProperty(exports, "arrayAll", { enumerable: true, get: function () { return operators_2.arrayAll; } });
+// Search operators
+Object.defineProperty(exports, "startsWith", { enumerable: true, get: function () { return operators_2.startsWith; } });
+Object.defineProperty(exports, "notStartsWith", { enumerable: true, get: function () { return operators_2.notStartsWith; } });
+Object.defineProperty(exports, "endsWith", { enumerable: true, get: function () { return operators_2.endsWith; } });
+Object.defineProperty(exports, "notEndsWith", { enumerable: true, get: function () { return operators_2.notEndsWith; } });
+Object.defineProperty(exports, "substring", { enumerable: true, get: function () { return operators_2.substring; } });
+Object.defineProperty(exports, "notSubstring", { enumerable: true, get: function () { return operators_2.notSubstring; } });
+// Array ANY/ALL operators
+Object.defineProperty(exports, "any", { enumerable: true, get: function () { return operators_2.any; } });
+Object.defineProperty(exports, "all", { enumerable: true, get: function () { return operators_2.all; } });
+// SQL Functions
+Object.defineProperty(exports, "fn", { enumerable: true, get: function () { return operators_2.fn; } });
+Object.defineProperty(exports, "col", { enumerable: true, get: function () { return operators_2.col; } });
+Object.defineProperty(exports, "literal", { enumerable: true, get: function () { return operators_2.literal; } });
+Object.defineProperty(exports, "literalExpr", { enumerable: true, get: function () { return operators_2.literalExpr; } });
+Object.defineProperty(exports, "isFnExpression", { enumerable: true, get: function () { return operators_2.isFnExpression; } });
+Object.defineProperty(exports, "isColExpression", { enumerable: true, get: function () { return operators_2.isColExpression; } });
+Object.defineProperty(exports, "isLiteralExpression", { enumerable: true, get: function () { return operators_2.isLiteralExpression; } });
+Object.defineProperty(exports, "isRawLiteral", { enumerable: true, get: function () { return operators_2.isRawLiteral; } });
+// Cast/Extract/Convert functions
+Object.defineProperty(exports, "cast", { enumerable: true, get: function () { return operators_2.cast; } });
+Object.defineProperty(exports, "extract", { enumerable: true, get: function () { return operators_2.extract; } });
+Object.defineProperty(exports, "conv", { enumerable: true, get: function () { return operators_2.conv; } });
+Object.defineProperty(exports, "isCastExpression", { enumerable: true, get: function () { return operators_2.isCastExpression; } });
+Object.defineProperty(exports, "isExtractExpression", { enumerable: true, get: function () { return operators_2.isExtractExpression; } });
+Object.defineProperty(exports, "isConvExpression", { enumerable: true, get: function () { return operators_2.isConvExpression; } });
+// Cast helpers
+Object.defineProperty(exports, "Cast", { enumerable: true, get: function () { return operators_2.Cast; } });
+// Full-text search operators
+Object.defineProperty(exports, "matchAgainst", { enumerable: true, get: function () { return operators_2.matchAgainst; } });
+Object.defineProperty(exports, "matchFulltext", { enumerable: true, get: function () { return operators_2.matchFulltext; } });
+Object.defineProperty(exports, "toTsvector", { enumerable: true, get: function () { return operators_2.toTsvector; } });
+Object.defineProperty(exports, "toTsquery", { enumerable: true, get: function () { return operators_2.toTsquery; } });
+Object.defineProperty(exports, "plainToTsquery", { enumerable: true, get: function () { return operators_2.plainToTsquery; } });
+Object.defineProperty(exports, "phraseToTsquery", { enumerable: true, get: function () { return operators_2.phraseToTsquery; } });
+// Re-export order helper functions
+var operators_3 = require("../operators");
+Object.defineProperty(exports, "asc", { enumerable: true, get: function () { return operators_3.asc; } });
+Object.defineProperty(exports, "desc", { enumerable: true, get: function () { return operators_3.desc; } });
+Object.defineProperty(exports, "random", { enumerable: true, get: function () { return operators_3.random; } });
+Object.defineProperty(exports, "isOrderExpression", { enumerable: true, get: function () { return operators_3.isOrderExpression; } });