@antfly/embedded 0.0.0-stage → 0.3.0-rc.1

package/dist/kysely.cjs

@@ -0,0 +1,346 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/kysely.ts
+var kysely_exports = {};
+__export(kysely_exports, {
+  AntflyDialect: () => AntflyDialect
+});
+module.exports = __toCommonJS(kysely_exports);
+var import_kysely = require("kysely");
+
+// src/sql-types.ts
+var SqlError = class extends Error {
+  constructor(diagnostic, transactionId) {
+    super(`${diagnostic.code}: ${diagnostic.message}`);
+    this.diagnostic = diagnostic;
+    this.transactionId = transactionId;
+    this.name = "SqlError";
+    this.sqlstate = diagnostic.code;
+  }
+  diagnostic;
+  transactionId;
+  sqlstate;
+};
+
+// src/sql.ts
+function request(statement, parameters, session, streaming = false) {
+  return JSON.stringify(
+    { statement, parameters, session_id: session, limit: streaming ? void 0 : 4096 },
+    (_key, value) => {
+      if (typeof value === "bigint") {
+        if (value < -(1n << 63n) || value >= 1n << 63n)
+          throw new RangeError("integer parameter is outside the signed 64-bit range");
+        return value.toString();
+      }
+      if (typeof value === "number" && (!Number.isFinite(value) || Number.isInteger(value) && !Number.isSafeInteger(value)))
+        throw new RangeError("use bigint for integer parameters outside JavaScript's safe range");
+      return value;
+    }
+  );
+}
+function result(wire) {
+  return {
+    columns: wire.columns,
+    commandTag: wire.command_tag,
+    rowsAffected: BigInt(wire.rows_affected),
+    rows: wire.rows.map(
+      (row, rowIndex) => Object.fromEntries(
+        wire.columns.map((column, index) => [
+          column.name,
+          wire.sql_nulls?.[rowIndex]?.[index] ? null : column.type === "integer" && row[index] !== null ? BigInt(row[index]) : row[index]
+        ])
+      )
+    )
+  };
+}
+var Connection = class _Connection {
+  constructor(database, session, direct = false) {
+    this.database = database;
+    this.session = session;
+    this.direct = direct;
+  }
+  database;
+  session;
+  direct;
+  #pending = Promise.resolve();
+  #closed = false;
+  static async open(database) {
+    return new _Connection(database, await database.openSqlSession());
+  }
+  #run(operation) {
+    if (this.#closed) return Promise.reject(new Error("SQL connection is closed"));
+    if (this.direct) return operation();
+    const work = this.#pending.then(operation);
+    this.#pending = work.catch(() => void 0);
+    return work;
+  }
+  execute(statement, parameters = []) {
+    return this.#run(
+      async () => result(
+        await this.database.sqlJson(request(statement, parameters, this.session))
+      )
+    );
+  }
+  query(statement, parameters = []) {
+    return this.#run(async () => {
+      let cursor;
+      try {
+        cursor = await this.database.openSqlCursor(
+          request(statement, parameters, this.session, true)
+        );
+      } catch (error) {
+        if (!(error instanceof SqlError) || error.sqlstate !== "0A000") throw error;
+        return result(
+          await this.database.sqlJson(request(statement, parameters, this.session))
+        );
+      }
+      let output;
+      try {
+        while (true) {
+          const page = await this.database.fetchSqlCursor(cursor);
+          const decoded = result(page.result);
+          if (output) output.rows.push(...decoded.rows);
+          else output = decoded;
+          if (page.exhausted) return output;
+        }
+      } finally {
+        await this.database.closeSqlCursor(cursor);
+      }
+    });
+  }
+  async *stream(statement, parameters = [], chunkSize = 128) {
+    if (!Number.isInteger(chunkSize) || chunkSize < 1 || chunkSize > 4096)
+      throw new RangeError("chunkSize must be 1..4096");
+    if (this.#closed) throw new Error("SQL connection is closed");
+    const previous = this.#pending;
+    let release = () => {
+    };
+    if (!this.direct)
+      this.#pending = new Promise((resolve) => {
+        release = resolve;
+      });
+    await previous;
+    let cursor;
+    try {
+      cursor = await this.database.openSqlCursor(
+        request(statement, parameters, this.session, true)
+      );
+      while (true) {
+        const page = await this.database.fetchSqlCursor(cursor, chunkSize);
+        yield result(page.result);
+        if (page.exhausted) break;
+      }
+    } finally {
+      try {
+        if (cursor !== void 0) await this.database.closeSqlCursor(cursor);
+      } finally {
+        release();
+      }
+    }
+  }
+  transaction(operation) {
+    return this.#run(async () => {
+      const transaction = new _Connection(this.database, this.session, true);
+      await transaction.execute("BEGIN ISOLATION LEVEL READ COMMITTED");
+      try {
+        const value = await operation(transaction);
+        await transaction.execute("COMMIT");
+        return value;
+      } catch (error) {
+        try {
+          await transaction.execute("ROLLBACK");
+        } catch {
+        }
+        throw error;
+      } finally {
+        transaction.#closed = true;
+      }
+    });
+  }
+  async close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    await this.#pending;
+    await this.database.closeSqlSession(this.session);
+  }
+};
+
+// src/kysely.ts
+var KyselyConnection = class {
+  constructor(sql) {
+    this.sql = sql;
+  }
+  sql;
+  async executeQuery(query, options) {
+    options?.signal?.throwIfAborted();
+    const result2 = await this.sql.query(query.sql, query.parameters);
+    return { rows: result2.rows, numAffectedRows: result2.rowsAffected };
+  }
+  async *streamQuery(query, chunkSize, options) {
+    options?.signal?.throwIfAborted();
+    for await (const page of this.sql.stream(query.sql, query.parameters, chunkSize)) {
+      options?.signal?.throwIfAborted();
+      yield { rows: page.rows, numAffectedRows: page.rowsAffected };
+    }
+  }
+};
+var AntflyDriver = class {
+  constructor(database) {
+    this.database = database;
+  }
+  database;
+  #connections = /* @__PURE__ */ new Set();
+  #destroyed = false;
+  async init() {
+  }
+  async acquireConnection(options) {
+    options?.signal?.throwIfAborted();
+    if (this.#destroyed) throw new Error("Antfly driver is destroyed");
+    const connection = new KyselyConnection(await Connection.open(this.database));
+    this.#connections.add(connection);
+    return connection;
+  }
+  async beginTransaction(connection, settings) {
+    if (settings.isolationLevel && settings.isolationLevel !== "read committed")
+      throw new Error("Antfly supports READ COMMITTED isolation");
+    await connection.sql.execute(
+      `BEGIN ISOLATION LEVEL READ COMMITTED${settings.accessMode === "read only" ? " READ ONLY" : ""}`
+    );
+  }
+  async commitTransaction(connection) {
+    await connection.sql.execute("COMMIT");
+  }
+  async rollbackTransaction(connection) {
+    await connection.sql.execute("ROLLBACK");
+  }
+  async savepoint(connection, name) {
+    await connection.sql.execute(`SAVEPOINT "${name.replaceAll('"', '""')}"`);
+  }
+  async rollbackToSavepoint(connection, name) {
+    await connection.sql.execute(
+      `ROLLBACK TO SAVEPOINT "${name.replaceAll('"', '""')}"`
+    );
+  }
+  async releaseSavepoint(connection, name) {
+    await connection.sql.execute(
+      `RELEASE SAVEPOINT "${name.replaceAll('"', '""')}"`
+    );
+  }
+  async releaseConnection(connection) {
+    const c = connection;
+    this.#connections.delete(c);
+    await c.sql.close();
+  }
+  async destroy() {
+    this.#destroyed = true;
+    await Promise.all([...this.#connections].map((c) => this.releaseConnection(c)));
+  }
+};
+var migrationLocks = /* @__PURE__ */ new WeakMap();
+var AntflyAdapter = class extends import_kysely.PostgresAdapter {
+  constructor(database) {
+    super();
+    this.database = database;
+  }
+  database;
+  #release;
+  async acquireMigrationLock(_db, _options) {
+    const prior = migrationLocks.get(this.database) ?? Promise.resolve();
+    let release = () => {
+    };
+    const mine = new Promise((resolve) => {
+      release = resolve;
+    });
+    migrationLocks.set(
+      this.database,
+      prior.then(() => mine)
+    );
+    await prior;
+    this.#release = release;
+  }
+  async releaseMigrationLock(_db, _options) {
+    this.#release?.();
+    this.#release = void 0;
+  }
+  get supportsTransactionalDdl() {
+    return false;
+  }
+};
+var AntflyDialect = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  createDriver() {
+    return new AntflyDriver(this.config.database);
+  }
+  createQueryCompiler() {
+    return new import_kysely.PostgresQueryCompiler();
+  }
+  createAdapter() {
+    return new AntflyAdapter(this.config.database);
+  }
+  createIntrospector() {
+    const database = this.config.database;
+    return {
+      async getSchemas() {
+        return [{ name: "public" }];
+      },
+      async getTables(options) {
+        const names = (await database.listTables()).filter(
+          (name) => name !== "default" && (options?.withInternalKyselyTables || !name.startsWith("kysely_"))
+        );
+        return Promise.all(
+          names.map(async (name) => {
+            const table = `"${name.replaceAll('"', '""')}"`;
+            const described = await database.sqlJson({
+              statement: `SELECT * FROM ${table} LIMIT 0`
+            });
+            const handle = await database.openTable(name);
+            let schema;
+            try {
+              schema = await handle.getSchema();
+            } finally {
+              await handle.close();
+            }
+            const document = schema.document_schemas?.[schema.default_type ?? "row"]?.schema;
+            return {
+              name,
+              schema: "public",
+              isView: false,
+              isForeign: false,
+              columns: described.columns.map((column) => ({
+                name: column.name,
+                dataType: column.type,
+                isNullable: column.name !== "_id" && !document?.required?.includes(column.name) && document?.properties?.[column.name]?.nullable !== false,
+                isAutoIncrementing: false,
+                hasDefaultValue: schema.column_defaults?.some((entry) => entry.column === column.name) ?? false
+              }))
+            };
+          })
+        );
+      }
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AntflyDialect
+});

package/dist/kysely.d.cts

@@ -0,0 +1,28 @@
+import { Dialect, Driver, PostgresQueryCompiler, PostgresAdapter, Kysely, MigrationLockOptions, DatabaseIntrospector } from 'kysely';
+import { D as Database } from './database-BY3WSLgt.cjs';
+import 'koffi';
+
+declare class AntflyAdapter extends PostgresAdapter {
+    #private;
+    readonly database: Database;
+    constructor(database: Database);
+    acquireMigrationLock(_db: Kysely<unknown>, _options: MigrationLockOptions): Promise<void>;
+    releaseMigrationLock(_db: Kysely<unknown>, _options: MigrationLockOptions): Promise<void>;
+    get supportsTransactionalDdl(): boolean;
+}
+/** PostgreSQL-style SQL compilation with an in-process Antfly session driver.
+ * The caller retains ownership of the supplied Database. */
+declare class AntflyDialect implements Dialect {
+    readonly config: {
+        database: Database;
+    };
+    constructor(config: {
+        database: Database;
+    });
+    createDriver(): Driver;
+    createQueryCompiler(): PostgresQueryCompiler;
+    createAdapter(): AntflyAdapter;
+    createIntrospector(): DatabaseIntrospector;
+}
+
+export { AntflyDialect };

package/dist/kysely.d.ts

@@ -0,0 +1,28 @@
+import { Dialect, Driver, PostgresQueryCompiler, PostgresAdapter, Kysely, MigrationLockOptions, DatabaseIntrospector } from 'kysely';
+import { D as Database } from './database-BY3WSLgt.js';
+import 'koffi';
+
+declare class AntflyAdapter extends PostgresAdapter {
+    #private;
+    readonly database: Database;
+    constructor(database: Database);
+    acquireMigrationLock(_db: Kysely<unknown>, _options: MigrationLockOptions): Promise<void>;
+    releaseMigrationLock(_db: Kysely<unknown>, _options: MigrationLockOptions): Promise<void>;
+    get supportsTransactionalDdl(): boolean;
+}
+/** PostgreSQL-style SQL compilation with an in-process Antfly session driver.
+ * The caller retains ownership of the supplied Database. */
+declare class AntflyDialect implements Dialect {
+    readonly config: {
+        database: Database;
+    };
+    constructor(config: {
+        database: Database;
+    });
+    createDriver(): Driver;
+    createQueryCompiler(): PostgresQueryCompiler;
+    createAdapter(): AntflyAdapter;
+    createIntrospector(): DatabaseIntrospector;
+}
+
+export { AntflyDialect };

package/dist/kysely.js

@@ -0,0 +1,169 @@
+import {
+  Connection
+} from "./chunk-ELM44XQ4.js";
+
+// src/kysely.ts
+import {
+  PostgresAdapter,
+  PostgresQueryCompiler
+} from "kysely";
+var KyselyConnection = class {
+  constructor(sql) {
+    this.sql = sql;
+  }
+  sql;
+  async executeQuery(query, options) {
+    options?.signal?.throwIfAborted();
+    const result = await this.sql.query(query.sql, query.parameters);
+    return { rows: result.rows, numAffectedRows: result.rowsAffected };
+  }
+  async *streamQuery(query, chunkSize, options) {
+    options?.signal?.throwIfAborted();
+    for await (const page of this.sql.stream(query.sql, query.parameters, chunkSize)) {
+      options?.signal?.throwIfAborted();
+      yield { rows: page.rows, numAffectedRows: page.rowsAffected };
+    }
+  }
+};
+var AntflyDriver = class {
+  constructor(database) {
+    this.database = database;
+  }
+  database;
+  #connections = /* @__PURE__ */ new Set();
+  #destroyed = false;
+  async init() {
+  }
+  async acquireConnection(options) {
+    options?.signal?.throwIfAborted();
+    if (this.#destroyed) throw new Error("Antfly driver is destroyed");
+    const connection = new KyselyConnection(await Connection.open(this.database));
+    this.#connections.add(connection);
+    return connection;
+  }
+  async beginTransaction(connection, settings) {
+    if (settings.isolationLevel && settings.isolationLevel !== "read committed")
+      throw new Error("Antfly supports READ COMMITTED isolation");
+    await connection.sql.execute(
+      `BEGIN ISOLATION LEVEL READ COMMITTED${settings.accessMode === "read only" ? " READ ONLY" : ""}`
+    );
+  }
+  async commitTransaction(connection) {
+    await connection.sql.execute("COMMIT");
+  }
+  async rollbackTransaction(connection) {
+    await connection.sql.execute("ROLLBACK");
+  }
+  async savepoint(connection, name) {
+    await connection.sql.execute(`SAVEPOINT "${name.replaceAll('"', '""')}"`);
+  }
+  async rollbackToSavepoint(connection, name) {
+    await connection.sql.execute(
+      `ROLLBACK TO SAVEPOINT "${name.replaceAll('"', '""')}"`
+    );
+  }
+  async releaseSavepoint(connection, name) {
+    await connection.sql.execute(
+      `RELEASE SAVEPOINT "${name.replaceAll('"', '""')}"`
+    );
+  }
+  async releaseConnection(connection) {
+    const c = connection;
+    this.#connections.delete(c);
+    await c.sql.close();
+  }
+  async destroy() {
+    this.#destroyed = true;
+    await Promise.all([...this.#connections].map((c) => this.releaseConnection(c)));
+  }
+};
+var migrationLocks = /* @__PURE__ */ new WeakMap();
+var AntflyAdapter = class extends PostgresAdapter {
+  constructor(database) {
+    super();
+    this.database = database;
+  }
+  database;
+  #release;
+  async acquireMigrationLock(_db, _options) {
+    const prior = migrationLocks.get(this.database) ?? Promise.resolve();
+    let release = () => {
+    };
+    const mine = new Promise((resolve) => {
+      release = resolve;
+    });
+    migrationLocks.set(
+      this.database,
+      prior.then(() => mine)
+    );
+    await prior;
+    this.#release = release;
+  }
+  async releaseMigrationLock(_db, _options) {
+    this.#release?.();
+    this.#release = void 0;
+  }
+  get supportsTransactionalDdl() {
+    return false;
+  }
+};
+var AntflyDialect = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  createDriver() {
+    return new AntflyDriver(this.config.database);
+  }
+  createQueryCompiler() {
+    return new PostgresQueryCompiler();
+  }
+  createAdapter() {
+    return new AntflyAdapter(this.config.database);
+  }
+  createIntrospector() {
+    const database = this.config.database;
+    return {
+      async getSchemas() {
+        return [{ name: "public" }];
+      },
+      async getTables(options) {
+        const names = (await database.listTables()).filter(
+          (name) => name !== "default" && (options?.withInternalKyselyTables || !name.startsWith("kysely_"))
+        );
+        return Promise.all(
+          names.map(async (name) => {
+            const table = `"${name.replaceAll('"', '""')}"`;
+            const described = await database.sqlJson({
+              statement: `SELECT * FROM ${table} LIMIT 0`
+            });
+            const handle = await database.openTable(name);
+            let schema;
+            try {
+              schema = await handle.getSchema();
+            } finally {
+              await handle.close();
+            }
+            const document = schema.document_schemas?.[schema.default_type ?? "row"]?.schema;
+            return {
+              name,
+              schema: "public",
+              isView: false,
+              isForeign: false,
+              columns: described.columns.map((column) => ({
+                name: column.name,
+                dataType: column.type,
+                isNullable: column.name !== "_id" && !document?.required?.includes(column.name) && document?.properties?.[column.name]?.nullable !== false,
+                isAutoIncrementing: false,
+                hasDefaultValue: schema.column_defaults?.some((entry) => entry.column === column.name) ?? false
+              }))
+            };
+          })
+        );
+      }
+    };
+  }
+};
+export {
+  AntflyDialect
+};

package/package.json

@@ -1,6 +1,89 @@
 {
   "name": "@antfly/embedded",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.3.0-rc.1",
+  "description": "TypeScript/Node binding for local Antfly databases and inference (libantfly C ABI)",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./kysely": {
+      "types": "./dist/kysely.d.ts",
+      "import": "./dist/kysely.js",
+      "require": "./dist/kysely.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run --maxWorkers=2",
+    "test:watch": "vitest",
+    "typecheck": "tsc -p tsconfig.typecheck.json",
+    "lint": "biome check .",
+    "clean": "rm -rf dist",
+    "prepare": "pnpm run build",
+    "prepublishOnly": "pnpm run typecheck && pnpm run lint && pnpm run build && pnpm run test"
+  },
+  "keywords": [
+    "antfly",
+    "lite",
+    "embedded",
+    "database",
+    "vector",
+    "search",
+    "koffi",
+    "ffi"
+  ],
+  "author": "Antfly Contributors",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/antflydb/antfly.git",
+    "directory": "ts/packages/embedded"
+  },
+  "bugs": {
+    "url": "https://github.com/antflydb/antfly/issues"
+  },
+  "homepage": "https://github.com/antflydb/antfly/tree/main/ts/packages/embedded#readme",
+  "devDependencies": {
+    "@types/node": "^25.9.3",
+    "kysely": "^0.29.6",
+    "tsup": "^8.5.1",
+    "typescript": "~5.9.3",
+    "vitest": "^4.1.9"
+  },
+  "dependencies": {
+    "koffi": "^3.3.1"
+  },
+  "engines": {
+    "node": ">=24.0"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "optionalDependencies": {
+    "@antfly/embedded-darwin-arm64": "0.3.0-rc.1",
+    "@antfly/embedded-linux-arm64": "0.3.0-rc.1",
+    "@antfly/embedded-linux-x64": "0.3.0-rc.1"
+  },
+  "peerDependencies": {
+    "kysely": "^0.29.6"
+  },
+  "peerDependenciesMeta": {
+    "kysely": {
+      "optional": true
+    }
+  }
+}