@ragestudio/scylla-odm 0.15.0 → 0.16.0

package/README.md

@@ -0,0 +1,246 @@
+# @ragestudio/scylla-odm
+
+> A lightweight ODM for ScyllaDB and Cassandra.
+
+> **Warning:** under active development, not production-ready.
+
+---
+
+## why this exists
+
+Most of (not existent) Node.js ODMs for ScyllaDB/Cassandra rely on the official `cassandra-driver`.
+
+The official `cassandra-driver` ships a built-in mapper, but it has no
+TypeScript support or a friendly interface.
+You define your columns with plain strings and get
+plain objects back — no autocomplete, no type checking, no safety net.
+
+This ODM is built on top of a modified `cassandra-driver` and adds:
+
+- **Type-safe schemas** — your column types are inferred, so `find`,
+  `create`, and `save` all know the shape of your data
+- **ODM Methods** — easier & friendly API for interacting with your data
+- **Full TypeScript support** — autocomplete, type checking, and inference
+  from schema to model to document
+- **MongoDB-style query operators** — `$gt`, `$in`, `$lte`, etc., all typed
+
+We also stripped out everything you probably never use (DataStax Insights,
+metrics, heavy dependencies, and other services) and applied a bunch of performance patches on
+top of the driver itself.
+
+The result is a leaner driver with less overhead, fewer timers, and better
+memory usage.
+
+---
+
+## install
+
+```bash
+npm install @ragestudio/scylla-odm
+```
+
+---
+
+## quick start
+
+```ts
+import Client, { Schema, Model, ColumnTypes } from "@ragestudio/scylla-odm";
+import type { Column } from "@ragestudio/scylla-odm/types";
+
+// 1. define a schema
+const userSchema = new Schema(
+  {
+    table_name: "users",
+    keys: ["id"], // partition key and clustering keys
+  },
+  {
+    id: { type: ColumnTypes.Int, required: true } as Column<number>,
+    name: { type: ColumnTypes.Text, required: true } as Column<string>,
+    email: { type: ColumnTypes.Text, required: true } as Column<string>,
+    age: { type: ColumnTypes.Int } as Column<number>,
+  },
+);
+
+// 2. create a model
+const User = new Model("User", userSchema);
+
+// 3. create a client
+const client = new Client({
+  contactPoints: ["127.0.0.1"],
+  localDataCenter: "datacenter1",
+  keyspace: "myapp",
+});
+
+// 4. initialize and connect
+await client.initialize();
+
+// 4. create and save documents
+const user = User.create({
+  id: 1234,
+  name: "Alice",
+  email: "alice@example.com",
+  age: 30,
+});
+
+await user.save();
+
+// 5. query
+const found = await User.findOne({ id: 1234 });
+console.log(found?.name); // "Alice"
+
+// 6. shutdown
+await client.shutdown();
+```
+
+---
+
+## schema
+
+A schema describes a table: its name, primary keys, and columns.
+
+```ts
+const productSchema = new Schema(
+  {
+    table_name: "products",
+    keys: [["category"], "id"], // compound partition key
+    clustering_order: { created_at: "desc" }, // optional
+  },
+  {
+    category: { type: ColumnTypes.Text, required: true } as Column<string>,
+    id: { type: ColumnTypes.Uuid, required: true } as Column<string>,
+    title: { type: ColumnTypes.Text, required: true } as Column<string>,
+    price: { type: ColumnTypes.Double, required: true } as Column<number>,
+    created_at: { type: ColumnTypes.Timestamp } as Column<Date>,
+  },
+);
+```
+
+---
+
+## model
+
+A model wraps a schema and provides the query interface.
+
+```ts
+const Product = new Model("Product", productSchema);
+```
+
+### methods
+
+| method                     | description                                                                                                                                                                          |
+| -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `create(data)` / `obj()`   | create a new document (not persisted yet)                                                                                                                                            |
+| `find(query, options?)`    | find documents matching the query, returns an array of documents                                                                                                                     |
+| `findOne(query, options?)` | find a single document, if no document is found, returns `null`. Due the mapper limitation, note that all partition and clustering keys must be defined in order to use this method. |
+|  |
+| `update(query)`            | update documents matching the query                                                                                                                                                  |
+| `delete(query)`            | delete documents matching the query                                                                                                                                                  |
+| `countAll()`               | count all documents in the table                                                                                                                                                     |
+
+---
+
+## document
+
+Documents are the objects you work with. They carry the data and a few helpers.
+
+```ts
+const product = Product.create({
+  category: "books",
+  id: uuid(),
+  title: "ODM 101",
+  price: 29.99,
+});
+
+await product.save(); // persist to ScyllaDB
+await product.delete(); // delete from ScyllaDB
+product.toRaw(); // plain object without internal fields
+product.getChangedFields(original); // diff between current and original data
+```
+
+---
+
+## query operators
+
+Use MongoDB-style operators in your queries:
+
+```ts
+// exact match
+await User.find({ name: "Alice" });
+
+// comparison operators
+await Product.find({ price: { $gt: 10, $lte: 50 } });
+
+// list matching
+await User.find({ age: { $in: [25, 30, 35] } });
+
+// sorting
+await Product.find({ category: "books" }, { $orderby: { created_at: "desc" } });
+
+// raw results (skip document wrapping)
+const raw = await Product.find({ category: "books" }, { raw: true });
+```
+
+---
+
+## configuration
+
+```ts
+const client = new Client({
+  modelsPath: "./db",
+  contactPoints: ["127.0.0.1"],
+  localDataCenter: "datacenter1",
+  keyspace: "myapp",
+  port: 9042,
+  maxRetries: 3,
+  retryDelay: 1000,
+  pooling: {
+    coreConnectionsPerHost: {
+      local: 2,
+    },
+    maxRequestsPerConnection: 1024,
+  },
+});
+```
+
+You can also configure via environment variables:
+
+| variable                   | default            |
+| -------------------------- | ------------------ |
+| `SCYLLA_CONTACT_POINTS`    | `127.0.0.1`        |
+| `SCYLLA_LOCAL_DATA_CENTER` | `datacenter1`      |
+| `SCYLLA_KEYSPACE`          | `default_keyspace` |
+
+---
+
+## about the driver
+
+This package ships a modified version of the `cassandra-driver`
+
+---
+
+## license
+
+This project is licensed under the [MIT license](https://opensource.org/licenses/MIT).
+
+The bundled `cassandra-driver` is licensed under the
+[Apache License, Version 2.0](src/driver/LICENSE.txt).
+
+```
+Apache Cassandra NodeJS Driver
+Copyright 2013 The Apache Software Foundation
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+```
+
+See [`src/driver/LICENSE.txt`](src/driver/LICENSE.txt) and
+[`src/driver/NOTICE.txt`](src/driver/NOTICE.txt) for the full legal text.

package/_virtual/_rolldown/runtime.js

@@ -1,26 +1 @@
-import { createRequire } from "node:module";
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-//#endregion
-export { __commonJSMin, __require, __toESM };
+var e=Object.defineProperty,t=(t,n)=>{let r={};for(var i in t)e(r,i,{get:t[i],enumerable:!0});return n||e(r,Symbol.toStringTag,{value:`Module`}),r};export{t as __exportAll};

package/client.d.ts

@@ -22,5 +22,4 @@ declare class Client {
   private isRetryableError;
 }
 //#endregion
-export { Client, Client as default };
-//# sourceMappingURL=client.d.ts.map
+export { Client, Client as default };

package/client.js

@@ -1,119 +1 @@
-import { __toESM } from "./_virtual/_rolldown/runtime.js";
-import { require_driver } from "./driver/index.js";
-import { Model } from "./model/index.js";
-import { Logger } from "./logger/index.js";
-import loadModels_default from "./utils/loadModels.js";
-import buildMapper_default from "./utils/buildMapper.js";
-import delay from "./utils/delay.js";
-import path from "node:path";
-//#region src/client.ts
-var import_driver = /* @__PURE__ */ __toESM(require_driver(), 1);
-const DEFAULT_MAX_RETRIES = 3;
-const DEFAULT_RETRY_DELAY = 1e3;
-const { SCYLLA_CONTACT_POINTS, SCYLLA_LOCAL_DATA_CENTER, SCYLLA_KEYSPACE } = process.env;
-var Client = class {
-	constructor(config = {}) {
-		if (globalThis.__scylla_client) throw new Error("An instance of Scylla Client is already initialized");
-		this.config = {
-			modelsPath: path.resolve(process.cwd(), "db"),
-			contactPoints: config.contactPoints ?? SCYLLA_CONTACT_POINTS?.split(",") ?? ["127.0.0.1"],
-			localDataCenter: config.localDataCenter ?? SCYLLA_LOCAL_DATA_CENTER ?? "datacenter1",
-			keyspace: config.keyspace ?? SCYLLA_KEYSPACE ?? "default_keyspace",
-			port: 9042,
-			maxRetries: DEFAULT_MAX_RETRIES,
-			retryDelay: DEFAULT_RETRY_DELAY,
-			...config
-		};
-		const clientOptions = {
-			contactPoints: this.config.contactPoints,
-			localDataCenter: this.config.localDataCenter,
-			keyspace: this.config.keyspace,
-			protocolOptions: { port: this.config.port }
-		};
-		if (this.config.pooling) clientOptions.pooling = this.config.pooling;
-		this.driver = new import_driver.Client(clientOptions);
-	}
-	config;
-	driver;
-	mapper;
-	models = /* @__PURE__ */ new Map();
-	model(name) {
-		return this.models.get(name);
-	}
-	logger = new Logger();
-	async initialize(options = {}) {
-		let models;
-		try {
-			models = await loadModels_default(this.config.modelsPath);
-		} catch (error) {
-			throw new Error(`Failed to load models: ${error.message}`);
-		}
-		models = models.filter((schema) => schema instanceof Model);
-		this.mapper = new import_driver.mapping.Mapper(this.driver, { models: buildMapper_default(models) });
-		globalThis.__scylla_client = this;
-		this.logger.log("Connecting...");
-		await this.connectWithRetry();
-		this.logger.log("Connected");
-		for (let model of models) {
-			this.models.set(model.name, model);
-			if (options?.sync === true) await model._sync();
-		}
-	}
-	async shutdown() {
-		try {
-			await this.driver.shutdown();
-			this.logger.log("connection closed");
-			delete globalThis.__scylla_client;
-		} catch (error) {
-			this.logger.error("error shutting down connection:", error);
-			throw error;
-		}
-	}
-	async connectWithRetry() {
-		let lastError = null;
-		for (let attempt = 1; attempt <= this.config.maxRetries; attempt++) try {
-			await this.driver.connect();
-			return;
-		} catch (error) {
-			lastError = error;
-			this.logger.warn(`Connection attempt ${attempt} failed: ${error.message}`);
-			if (attempt < this.config.maxRetries) {
-				this.logger.log(`Retrying in ${this.config.retryDelay}ms...`);
-				await delay(this.config.retryDelay);
-			}
-		}
-		throw new Error(`Failed to connect to ScyllaDB after ${this.config.maxRetries} attempts: ${lastError?.message}`);
-	}
-	async executeWithRetry(operation, operationName = "operation") {
-		let lastError = null;
-		for (let attempt = 1; attempt <= this.config.maxRetries; attempt++) try {
-			return await operation();
-		} catch (error) {
-			lastError = error;
-			if (this.isRetryableError(error) && attempt < this.config.maxRetries) {
-				this.logger.warn(`Operation ${operationName} attempt ${attempt} failed: ${error.message}`);
-				this.logger.log(`Retrying in ${this.config.retryDelay}ms...`);
-				await delay(this.config.retryDelay);
-				continue;
-			}
-			throw error;
-		}
-		throw new Error(`Operation ${operationName} failed after ${this.config.maxRetries} attempts: ${lastError?.message}`);
-	}
-	isRetryableError(error) {
-		const retryableMessages = [
-			"timeout",
-			"connection",
-			"network",
-			"unavailable",
-			"overloaded",
-			"no hosts available"
-		];
-		const errorMessage = error.message?.toLowerCase() || "";
-		return retryableMessages.some((msg) => errorMessage.includes(msg));
-	}
-};
-//#endregion
-export { Client, Client as default };
-
-//# sourceMappingURL=client.js.map
+import e from"./driver/index.js";import{Model as t}from"./model/index.js";import{Logger as n}from"./logger/index.js";import r from"./utils/loadModels.js";import i from"./utils/buildMapper.js";import a from"./utils/delay.js";import o from"node:path";const{SCYLLA_CONTACT_POINTS:s,SCYLLA_LOCAL_DATA_CENTER:c,SCYLLA_KEYSPACE:l}=process.env;var u=class{constructor(t={}){if(globalThis.__scylla_client)throw Error(`An instance of Scylla Client is already initialized`);this.config={modelsPath:o.resolve(process.cwd(),`db`),contactPoints:t.contactPoints??s?.split(`,`)??[`127.0.0.1`],localDataCenter:t.localDataCenter??c??`datacenter1`,keyspace:t.keyspace??l??`default_keyspace`,port:9042,maxRetries:3,retryDelay:1e3,...t};let n={contactPoints:this.config.contactPoints,localDataCenter:this.config.localDataCenter,keyspace:this.config.keyspace,protocolOptions:{port:this.config.port}};this.config.pooling&&(n.pooling=this.config.pooling),this.driver=new e.Client(n)}config;driver;mapper;models=new Map;model(e){return this.models.get(e)}logger=new n;async initialize(n={}){let a;try{a=await r(this.config.modelsPath)}catch(e){throw Error(`Failed to load models: ${e.message}`)}a=a.filter(e=>e instanceof t),this.mapper=new e.mapping.Mapper(this.driver,{models:i(a)}),globalThis.__scylla_client=this,this.logger.log(`Connecting...`),await this.connectWithRetry(),this.logger.log(`Connected`);for(let e of a)this.models.set(e.name,e),n?.sync===!0&&await e._sync()}async shutdown(){try{await this.driver.shutdown(),this.logger.log(`connection closed`),delete globalThis.__scylla_client}catch(e){throw this.logger.error(`error shutting down connection:`,e),e}}async connectWithRetry(){let e=null;for(let t=1;t<=this.config.maxRetries;t++)try{await this.driver.connect();return}catch(n){e=n,this.logger.warn(`Connection attempt ${t} failed: ${n.message}`),t<this.config.maxRetries&&(this.logger.log(`Retrying in ${this.config.retryDelay}ms...`),await a(this.config.retryDelay))}throw Error(`Failed to connect to ScyllaDB after ${this.config.maxRetries} attempts: ${e?.message}`)}async executeWithRetry(e,t=`operation`){let n=null;for(let r=1;r<=this.config.maxRetries;r++)try{return await e()}catch(e){if(n=e,this.isRetryableError(e)&&r<this.config.maxRetries){this.logger.warn(`Operation ${t} attempt ${r} failed: ${e.message}`),this.logger.log(`Retrying in ${this.config.retryDelay}ms...`),await a(this.config.retryDelay);continue}throw e}throw Error(`Operation ${t} failed after ${this.config.maxRetries} attempts: ${n?.message}`)}isRetryableError(e){let t=[`timeout`,`connection`,`network`,`unavailable`,`overloaded`,`no hosts available`],n=e.message?.toLowerCase()||``;return t.some(e=>n.includes(e))}};export{u as Client,u as default};

package/cql_gen/create_keyspace.d.ts

@@ -8,5 +8,4 @@ type KeyspaceCreateOptions = {
 };
 declare function createKeyspace(options: KeyspaceCreateOptions): string;
 //#endregion
-export { createKeyspace as default };
-//# sourceMappingURL=create_keyspace.d.ts.map
+export { createKeyspace as default };

package/cql_gen/create_keyspace.js

@@ -1,14 +1 @@
-//#region src/cql_gen/create_keyspace.ts
-function createKeyspace(options) {
-	let clause = {};
-	if (options.replication) clause = options.replication;
-	else clause = {
-		strategy: "SimpleStrategy",
-		options: { replication_factor: "1" }
-	};
-	return `CREATE KEYSPACE IF NOT EXISTS ${options.keyspace} WITH REPLICATION = ${JSON.stringify(clause)};`;
-}
-//#endregion
-export { createKeyspace as default };
-
-//# sourceMappingURL=create_keyspace.js.map
+function e(e){let t={};return t=e.replication?e.replication:{strategy:`SimpleStrategy`,options:{replication_factor:`1`}},`CREATE KEYSPACE IF NOT EXISTS ${e.keyspace} WITH REPLICATION = ${JSON.stringify(t)};`}export{e as default};

package/cql_gen/create_table.d.ts

@@ -3,5 +3,4 @@ import { Model } from "../model/index.js";
 //#region src/cql_gen/create_table.d.ts
 declare function export_default(model: Model): string;
 //#endregion
-export { export_default as default };
-//# sourceMappingURL=create_table.d.ts.map
+export { export_default as default };

package/cql_gen/create_table.js

@@ -1,38 +1 @@
-//#region src/cql_gen/create_table.ts
-function create_table_default(model) {
-	const desc = model.schema;
-	const tableName = desc.table_name;
-	const keyspace = model.client.config.keyspace;
-	const fields = desc.fields;
-	const key = desc.keys;
-	const clusteringOrder = desc.clustering_order;
-	let columnsDef = "";
-	for (const fieldName in fields) {
-		const field = fields[fieldName];
-		const typeStr = typeof field === "string" ? field : field?.type;
-		if (!typeStr) throw new Error(`Invalid field type for "${fieldName}" in model "${tableName}"`);
-		columnsDef += `"${fieldName}" ${typeStr.toUpperCase()}, `;
-	}
-	let pkDef = "";
-	if (typeof key === "string") pkDef = `"${key}"`;
-	else if (Array.isArray(key) && key.length > 0) {
-		const first = key[0];
-		if (Array.isArray(first)) pkDef = `(${first.map((k) => `"${k}"`).join(", ")})`;
-		else pkDef = `"${first}"`;
-		for (let i = 1; i < key.length; i++) pkDef += `, "${key[i]}"`;
-	} else throw new Error(`Missing or invalid primary key in model "${tableName}"`);
-	let clusterClause = "";
-	if (clusteringOrder) {
-		let orderDef = "";
-		for (const col in clusteringOrder) {
-			if (orderDef !== "") orderDef += ", ";
-			orderDef += `"${col}" ${clusteringOrder[col].toUpperCase()}`;
-		}
-		if (orderDef !== "") clusterClause = ` WITH CLUSTERING ORDER BY (${orderDef})`;
-	}
-	return `CREATE TABLE IF NOT EXISTS ${keyspace}.${tableName} (${columnsDef}PRIMARY KEY (${pkDef}))${clusterClause}`;
-}
-//#endregion
-export { create_table_default as default };
-
-//# sourceMappingURL=create_table.js.map
+function e(e){let t=e.schema,n=t.table_name,r=e.client.config.keyspace,i=t.fields,a=t.keys,o=t.clustering_order,s=``;for(let e in i){let t=i[e],r=typeof t==`string`?t:t?.type;if(!r)throw Error(`Invalid field type for "${e}" in model "${n}"`);s+=`"${e}" ${r.toUpperCase()}, `}let c=``;if(typeof a==`string`)c=`"${a}"`;else if(Array.isArray(a)&&a.length>0){let e=a[0];c=Array.isArray(e)?`(${e.map(e=>`"${e}"`).join(`, `)})`:`"${e}"`;for(let e=1;e<a.length;e++)c+=`, "${a[e]}"`}else throw Error(`Missing or invalid primary key in model "${n}"`);let l=``;if(o){let e=``;for(let t in o)e!==``&&(e+=`, `),e+=`"${t}" ${o[t].toUpperCase()}`;e!==``&&(l=` WITH CLUSTERING ORDER BY (${e})`)}return`CREATE TABLE IF NOT EXISTS ${r}.${n} (${s}PRIMARY KEY (${c}))${l}`}export{e as default};

package/document/index.d.ts

@@ -13,5 +13,4 @@ declare class Document<TDoc = any> {
   getChangedFields(original: Partial<TDoc>): (keyof TDoc)[];
 }
 //#endregion
-export { Document, Document as default };
-//# sourceMappingURL=index.d.ts.map
+export { Document, Document as default };

package/document/index.js

@@ -1,63 +1 @@
-//#region src/document/index.ts
-var Document = class {
-	constructor(data, model) {
-		if (data == null) throw new Error("Cannot create Document with null or undefined data");
-		if (typeof data !== "object" || Array.isArray(data)) throw new Error("Document data must be an object");
-		Object.assign(this, data);
-		Object.defineProperty(this, "_model", {
-			value: model,
-			enumerable: false,
-			writable: false,
-			configurable: false
-		});
-	}
-	_model;
-	async save() {
-		try {
-			const data = this.toRaw();
-			return await this._model.update(data);
-		} catch (error) {
-			throw new Error(`Failed to save document: ${error.message}`);
-		}
-	}
-	async delete() {
-		try {
-			return await this._model.delete(this.toRaw());
-		} catch (error) {
-			throw new Error(`Failed to delete document: ${error.message}`);
-		}
-	}
-	toRaw() {
-		const raw = {};
-		for (const key in this) {
-			if (key === "_model") continue;
-			if (this.propertyIsEnumerable(key)) {
-				const value = this[key];
-				try {
-					JSON.stringify(value);
-					raw[key] = value;
-				} catch (error) {
-					raw[key] = String(value);
-				}
-			}
-		}
-		return raw;
-	}
-	isValid() {
-		try {
-			return true;
-		} catch {
-			return false;
-		}
-	}
-	getChangedFields(original) {
-		const current = this.toRaw();
-		const changed = [];
-		for (const key in current) if (!(key in original) || current[key] !== original[key]) changed.push(key);
-		return changed;
-	}
-};
-//#endregion
-export { Document, Document as default };
-
-//# sourceMappingURL=index.js.map
+var e=class{constructor(e,t){if(e==null)throw Error(`Cannot create Document with null or undefined data`);if(typeof e!=`object`||Array.isArray(e))throw Error(`Document data must be an object`);Object.assign(this,e),Object.defineProperty(this,`_model`,{value:t,enumerable:!1,writable:!1,configurable:!1})}_model;async save(){try{let e=this.toRaw();return await this._model.update(e)}catch(e){throw Error(`Failed to save document: ${e.message}`)}}async delete(){try{return await this._model.delete(this.toRaw())}catch(e){throw Error(`Failed to delete document: ${e.message}`)}}toRaw(){let e={};for(let t in this)if(t!==`_model`&&this.propertyIsEnumerable(t)){let n=this[t];try{JSON.stringify(n),e[t]=n}catch{e[t]=String(n)}}return e}isValid(){try{return!0}catch{return!1}}getChangedFields(e){let t=this.toRaw(),n=[];for(let r in t)(!(r in e)||t[r]!==e[r])&&n.push(r);return n}};export{e as Document,e as default};

package/driver/index.d.ts

@@ -4,17 +4,21 @@ import { policies } from "./lib/policies/index.js";
 import { metrics } from "./lib/metrics/index.js";
 import { tracker } from "./lib/tracker/index.js";
 import { metadata } from "./lib/metadata/index.js";
+import { concurrent } from "./lib/concurrent/index.js";
 import { mapping } from "./lib/mapping/index.js";
-import * as events from "events";
-import * as tls from "tls";
+import { geometry } from "./lib/geometry/index.js";
+import * as events$1 from "events";
+import * as tls$1 from "tls";
 
-//#region driver/index.d.ts
+//#region src/driver/index.d.ts
+declare const version: number;
+declare function defaultOptions(): ClientOptions;
 type ValueCallback<T> = (err: Error, val: T) => void;
 type EmptyCallback = (err: Error) => void;
 type ArrayOrObject = any[] | {
   [key: string]: any;
 };
-declare class Client extends events.EventEmitter {
+declare class Client extends events$1.EventEmitter {
   hosts: HostMap;
   keyspace: string;
   metadata: metadata.Metadata;
@@ -39,7 +43,7 @@ declare class Client extends events.EventEmitter {
   eachRow(query: string, params: ArrayOrObject, options: QueryOptions, rowCallback: (n: number, row: types.Row) => void, callback?: ValueCallback<types.ResultSet>): void;
   eachRow(query: string, params: ArrayOrObject, rowCallback: (n: number, row: types.Row) => void, callback?: ValueCallback<types.ResultSet>): void;
   eachRow(query: string, rowCallback: (n: number, row: types.Row) => void): void;
-  stream(query: string, params?: ArrayOrObject, options?: QueryOptions, callback?: EmptyCallback): events.EventEmitter;
+  stream(query: string, params?: ArrayOrObject, options?: QueryOptions, callback?: EmptyCallback): events$1.EventEmitter;
   batch(queries: Array<string | {
     query: string;
     params?: ArrayOrObject;
@@ -57,14 +61,14 @@ declare class Client extends events.EventEmitter {
   getReplicas(keyspace: string, token: Buffer): Host[];
   getState(): metadata.ClientState;
 }
-interface HostMap extends events.EventEmitter {
+interface HostMap extends events$1.EventEmitter {
   length: number;
   forEach(callback: (value: Host, key: string) => void): void;
   get(key: string): Host;
   keys(): string[];
   values(): Host[];
 }
-interface Host extends events.EventEmitter {
+interface Host extends events$1.EventEmitter {
   address: string;
   cassandraVersion: string;
   datacenter: string;
@@ -159,7 +163,7 @@ interface ClientOptions {
     readTimeout?: number;
     tcpNoDelay?: boolean;
   };
-  sslOptions?: tls.ConnectionOptions;
+  sslOptions?: tls$1.ConnectionOptions;
 }
 interface QueryOptions {
   autoPage?: boolean;
@@ -297,5 +301,4 @@ declare namespace token {
   }
 }
 //#endregion
-export { Client, ClientOptions, EmptyCallback, ExecutionOptions, Host, HostMap, ValueCallback, errors, token };
-//# sourceMappingURL=index.d.ts.map
+export { ArrayOrObject, Client, ClientOptions, DseClientOptions, EmptyCallback, ExecutionOptions, ExecutionProfile, GraphOptions, GraphQueryOptions, Host, HostMap, QueryOptions, ValueCallback, auth, concurrent, defaultOptions, errors, geometry, mapping, metadata, metrics, policies, token, tracker, types, version };

package/driver/index.js

@@ -1,53 +1 @@
-import { __commonJSMin } from "../_virtual/_rolldown/runtime.js";
-import { require_errors } from "./lib/errors.js";
-import { require_types } from "./lib/types/index.js";
-import { require_policies } from "./lib/policies/index.js";
-import { require_tracker } from "./lib/tracker/index.js";
-import { require_metrics } from "./lib/metrics/index.js";
-import { require_auth } from "./lib/auth/index.js";
-import { require_client_options } from "./lib/client-options.js";
-import { require_execution_profile } from "./lib/execution-profile.js";
-import { require_execution_options } from "./lib/execution-options.js";
-import { require_package } from "../package.js";
-import { require_token } from "./lib/token.js";
-import { require_geometry } from "./lib/geometry/index.js";
-import { require_encoder } from "./lib/encoder.js";
-import { require_metadata } from "./lib/metadata/index.js";
-import { require_client } from "./lib/client.js";
-import { require_mapping } from "./lib/mapping/index.js";
-import { require_concurrent } from "./lib/concurrent/index.js";
-//#region driver/index.js
-var require_driver = /* @__PURE__ */ __commonJSMin(((exports) => {
-	const clientOptions = require_client_options();
-	exports.Client = require_client();
-	exports.ExecutionProfile = require_execution_profile().ExecutionProfile;
-	exports.ExecutionOptions = require_execution_options().ExecutionOptions;
-	exports.types = require_types();
-	exports.errors = require_errors();
-	exports.policies = require_policies();
-	exports.auth = require_auth();
-	exports.mapping = require_mapping();
-	exports.tracker = require_tracker();
-	exports.metrics = require_metrics();
-	exports.concurrent = require_concurrent();
-	const token = require_token();
-	exports.token = {
-		Token: token.Token,
-		TokenRange: token.TokenRange
-	};
-	exports.metadata = { Metadata: require_metadata() };
-	exports.Encoder = require_encoder();
-	exports.geometry = require_geometry();
-	/**
-	* Returns a new instance of the default [options]{@link ClientOptions} used by the driver.
-	*/
-	exports.defaultOptions = function() {
-		return clientOptions.defaultOptions();
-	};
-	exports.version = require_package().version;
-}));
-//#endregion
-export default require_driver();
-export { require_driver };
-
-//# sourceMappingURL=index.js.map
+import e from"./lib/errors.js";import t from"./lib/types/index.js";import n from"./lib/policies/index.js";import r from"./lib/tracker/index.js";import i from"./lib/metrics/index.js";import a from"./lib/auth/index.js";import o from"./lib/client-options.js";import{ExecutionProfile as s}from"./lib/execution-profile.js";import{ExecutionOptions as c}from"./lib/execution-options.js";import{version as l}from"../package.js";import{Token as u,TokenRange as d}from"./lib/token.js";import f from"./lib/geometry/index.js";import p from"./lib/encoder.js";import m from"./lib/metadata/index.js";import h from"./lib/client.js";import g from"./lib/mapping/index.js";import _ from"./lib/concurrent/index.js";const v={Token:u,TokenRange:d},y={Metadata:m};function b(){return o.defaultOptions()}const x={Client:h,ExecutionProfile:s,ExecutionOptions:c,types:t,errors:e,policies:n,auth:a,mapping:g,tracker:r,metrics:i,concurrent:_,token:v,metadata:y,Encoder:p,geometry:f,defaultOptions:b,version:l};export{x as default};