albedo-node 0.8.2 → 0.9.3

package/bun.lock

@@ -0,0 +1,25 @@
+{
+  "lockfileVersion": 1,
+  "configVersion": 0,
+  "workspaces": {
+    "": {
+      "name": "albedo-node",
+      "dependencies": {
+        "detect-libc": "^2.1.2",
+      },
+      "devDependencies": {
+        "@types/node": "^24.0.0",
+        "typescript": "^5.9.3",
+      },
+    },
+  },
+  "packages": {
+    "@types/node": ["@types/node@24.10.13", "", { "dependencies": { "undici-types": "~7.16.0" } }, "sha512-oH72nZRfDv9lADUBSo104Aq7gPHpQZc4BTx38r9xf9pg5LfP6EzSyH2n7qFmmxRQXh7YlUXODcYsg6PuTDSxGg=="],
+
+    "detect-libc": ["detect-libc@2.1.2", "", {}, "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ=="],
+
+    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
+
+    "undici-types": ["undici-types@7.16.0", "", {}, "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw=="],
+  }
+}

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+import { type QueryInput } from "./query";
+export * from "./query";
 type ByteBuffer = Uint8Array;
 type BucketHandle = object;
 type TransactionHandle = object;
@@ -113,7 +115,6 @@ export declare const BSON: {
  * ```
  */
 export declare const ObjectId: ObjectIdConstructor;
-type QueryInput = object | Query;
 type TransformReplacement<T extends object> = T | ByteBuffer | null;
 /**
  * Wrapper around a native transaction handle providing
@@ -241,7 +242,7 @@ export declare class Bucket {
      * bucket.delete(new Query().where('name', { $eq: 'Bob' }));
      * ```
      */
-    delete(query?: object | Query): void;
+    delete(query?: QueryInput): void;
     /**
      * Retrieve information about all indexes defined on the bucket.
      * @example
@@ -279,7 +280,7 @@ export declare class Bucket {
      * }
      * ```
      */
-    list<T>(query?: object | Query): Generator<T>;
+    list<T>(query?: QueryInput): Generator<T>;
     /**
      * Async iterator that continuously polls a change subscription.
      *
@@ -300,7 +301,7 @@ export declare class Bucket {
      * }
      * ```
      */
-    subscribe<T>(query?: object | Query, options?: SubscribeOptions): AsyncGenerator<SubscriptionEvent<T>>;
+    subscribe<T>(query?: QueryInput, options?: SubscribeOptions): AsyncGenerator<SubscriptionEvent<T>>;
     /**
      * Collect all documents matching the optional query into an array.
      * @param query - filter or `Query` object
@@ -310,7 +311,7 @@ export declare class Bucket {
      * const docs = bucket.all<{ name: string }>(where('name', { $exists: true }));
      * ```
      */
-    all<T>(query?: object | Query): Array<T>;
+    all<T>(query?: QueryInput): Array<T>;
     /**
      * Return the first document matching the optional query, or `null`
      * when no document matches.
@@ -321,7 +322,7 @@ export declare class Bucket {
      * const doc = bucket.one<{ _id: number }>(where('_id', { $eq: 1 }));
      * ```
      */
-    one<T>(query?: object | Query): T | null;
+    one<T>(query?: QueryInput): T | null;
     /**
      * Normalize a query argument to a plain object, unpacking
      * `Query` instances.
@@ -331,7 +332,7 @@ export declare class Bucket {
      * Bucket.convertToQuery({ foo: { $exists: true } });
      * ```
      */
-    static convertToQuery(query?: object | Query): object;
+    static convertToQuery(query?: QueryInput): object;
     /**
      * Generator that allows reading and optionally modifying each
      * document matching the query.
@@ -348,7 +349,7 @@ export declare class Bucket {
      * }
      * ```
      */
-    transformIterator<T extends object>(query?: object | Query): Generator<T, undefined, TransformReplacement<T>>;
+    transformIterator<T extends object>(query?: QueryInput): Generator<T, undefined, TransformReplacement<T>>;
     /**
      * Apply a transformation function to each document matching the
      * provided query. The predicate receives the current document and
@@ -367,11 +368,11 @@ export declare class Bucket {
      * });
      * ```
      */
-    transform<T extends object>(query: object | Query | undefined, fn: (doc: T) => TransformReplacement<T>): void;
+    transform<T extends object>(query: QueryInput | undefined, fn: (doc: T) => TransformReplacement<T>): void;
     /**
      * Alias for `transform` that reads more naturally for document updates.
      */
-    update<T extends object>(query: object | Query | undefined, fn: (doc: T) => TransformReplacement<T>): void;
+    update<T extends object>(query: QueryInput | undefined, fn: (doc: T) => TransformReplacement<T>): void;
     replicationCursor(): ReplicationCursor;
     readReplicationBatch(cursor: ReplicationCursor, maxBytes?: number): Uint8Array | null;
     /**
@@ -384,87 +385,3 @@ export declare class Bucket {
      */
     applyReplicationBatch(data: Uint8Array): ReplicationCursor;
 }
-type BSONValue = any;
-type FilterOperators = {
-    $eq: BSONValue;
-} | BSONValue | {
-    $ne: BSONValue;
-} | {
-    $lt: BSONValue;
-} | {
-    $lte: BSONValue;
-} | {
-    $gt: BSONValue;
-} | {
-    $gte: BSONValue;
-} | {
-    $in: BSONValue[];
-} | {
-    $between: [BSONValue, BSONValue];
-} | {
-    $startsWith: string;
-} | {
-    $endsWith: string;
-} | {
-    $exists: boolean;
-} | {
-    $notExists: boolean;
-};
-/**
- * Builder for query objects that can be used with bucket
- * operations like `list`, `delete`, and `transform`.
- *
- * The class supports chaining to construct filters, sorting,
- * and pagination (offset/limit).
- */
-export declare class Query {
-    private _query;
-    /**
-     * Return the raw query object to pass to the native layer.
-     */
-    get query(): object;
-    /**
-     * Add a filter condition for the specified field.
-     * @param field - dot-separated path to the document field
-     * @param filter - comparison operator object
-     * @returns the same `Query` for chaining
-     * @example
-     * ```ts
-     * const q = new Query().where('age', { $gt: 18 });
-     * ```
-     */
-    where(field: string, filter: FilterOperators): this;
-    /**
-     * Specify sorting for the result set.
-     * @param field - field to sort by
-     * @param direction - `asc` or `desc` (defaults to `asc`)
-     * @example
-     * ```ts
-     * const q = new Query().sortBy('name', 'desc');
-     * ```
-     */
-    sortBy(field: string, direction?: "asc" | "desc"): this;
-    /**
-     * Set an offset and limit for pagination.
-     * @param offset - number of documents to skip
-     * @param limit - maximum number of documents to return
-     * @example
-     * ```ts
-     * const q = new Query().sector(10, 5);
-     * ```
-     */
-    sector(offset?: number, limit?: number): this;
-}
-/**
- * Shortcut helper that creates a new `Query` with a single
- * `where` clause applied.
- *
- * @param field - field name to filter on
- * @param filter - filter operator object
- * @returns a `Query` instance ready to use
- * @example
- * ```ts
- * bucket.list(where('age', { $lt: 30 }));
- * ```
- */
-export declare function where(field: string, filter: FilterOperators): Query;

package/dist/index.js

@@ -1,8 +1,23 @@
 "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 });
-exports.Query = exports.Bucket = exports.Transaction = exports.ObjectId = exports.BSON = exports.albedo = void 0;
-exports.where = where;
+exports.Bucket = exports.Transaction = exports.ObjectId = exports.BSON = exports.albedo = void 0;
 const detect_libc_1 = require("detect-libc");
+const query_1 = require("./query");
+__exportStar(require("./query"), exports);
 function getNativeBinding() {
     const platformMap = {
         win32: "windows",
@@ -48,7 +63,7 @@ exports.BSON = {
  */
 exports.ObjectId = exports.albedo.ObjectId;
 function convertToQuery(query) {
-    if (query instanceof Query) {
+    if (query instanceof query_1.Query) {
         return query.query;
     }
     return query || {};
@@ -379,6 +394,7 @@ class Bucket {
         try {
             while (true) {
                 const batch = exports.albedo.subscribePoll(subscription, batchSize);
+                console.log("Polled subscription, got batch:", batch);
                 if (batch !== null) {
                     for (const event of batch.batch) {
                         yield event;
@@ -498,78 +514,3 @@ class Bucket {
     }
 }
 exports.Bucket = Bucket;
-/**
- * Builder for query objects that can be used with bucket
- * operations like `list`, `delete`, and `transform`.
- *
- * The class supports chaining to construct filters, sorting,
- * and pagination (offset/limit).
- */
-class Query {
-    _query = {};
-    /**
-     * Return the raw query object to pass to the native layer.
-     */
-    get query() {
-        return this._query;
-    }
-    /**
-     * Add a filter condition for the specified field.
-     * @param field - dot-separated path to the document field
-     * @param filter - comparison operator object
-     * @returns the same `Query` for chaining
-     * @example
-     * ```ts
-     * const q = new Query().where('age', { $gt: 18 });
-     * ```
-     */
-    where(field, filter) {
-        if (!this._query.query) {
-            this._query.query = {};
-        }
-        this._query.query[field] = filter;
-        return this;
-    }
-    /**
-     * Specify sorting for the result set.
-     * @param field - field to sort by
-     * @param direction - `asc` or `desc` (defaults to `asc`)
-     * @example
-     * ```ts
-     * const q = new Query().sortBy('name', 'desc');
-     * ```
-     */
-    sortBy(field, direction = "asc") {
-        this._query.sort = direction === "asc" ? { asc: field } : { desc: field };
-        return this;
-    }
-    /**
-     * Set an offset and limit for pagination.
-     * @param offset - number of documents to skip
-     * @param limit - maximum number of documents to return
-     * @example
-     * ```ts
-     * const q = new Query().sector(10, 5);
-     * ```
-     */
-    sector(offset, limit) {
-        this._query.sector = { offset, limit };
-        return this;
-    }
-}
-exports.Query = Query;
-/**
- * Shortcut helper that creates a new `Query` with a single
- * `where` clause applied.
- *
- * @param field - field name to filter on
- * @param filter - filter operator object
- * @returns a `Query` instance ready to use
- * @example
- * ```ts
- * bucket.list(where('age', { $lt: 30 }));
- * ```
- */
-function where(field, filter) {
-    return new Query().where(field, filter);
-}

package/dist/query.d.ts

@@ -0,0 +1,132 @@
+type BSONValue = any;
+export type FilterOperators = {
+    $eq: BSONValue;
+} | BSONValue | {
+    $ne: BSONValue;
+} | {
+    $lt: BSONValue;
+} | {
+    $lte: BSONValue;
+} | {
+    $gt: BSONValue;
+} | {
+    $gte: BSONValue;
+} | {
+    $in: BSONValue[];
+} | {
+    $between: [BSONValue, BSONValue];
+} | {
+    $startsWith: string;
+} | {
+    $endsWith: string;
+} | {
+    $exists: boolean;
+} | {
+    $notExists: boolean;
+};
+export interface QueryClause {
+    $or?: QueryClause[];
+    $and?: QueryClause[];
+    $nor?: QueryClause[];
+    [field: string]: FilterOperators | QueryClause[] | undefined;
+}
+export type QuerySort = {
+    asc: string;
+} | {
+    desc: string;
+};
+export interface QuerySector {
+    offset?: number;
+    limit?: number;
+}
+export interface QueryObject {
+    query?: QueryClause;
+    sort?: QuerySort;
+    sector?: QuerySector;
+    projection?: {
+        omit: string[];
+    } | {
+        pick: string[];
+    };
+    cursor?: Record<string, unknown>;
+}
+export type QueryInput = QueryObject | Query;
+export type QueryClauseInput = QueryClause | Query;
+/**
+ * Builder for query objects that can be used with bucket
+ * operations like `list`, `delete`, and `transform`.
+ *
+ * The class supports chaining to construct filters, sorting,
+ * and pagination (offset/limit).
+ */
+export declare class Query {
+    private _query;
+    static or(...clauses: QueryClauseInput[]): Query;
+    static and(...clauses: QueryClauseInput[]): Query;
+    static nor(...clauses: QueryClauseInput[]): Query;
+    /**
+     * Return the raw query object to pass to the native layer.
+     */
+    get query(): QueryObject;
+    /**
+     * Add a filter condition for the specified field.
+     * @param field - dot-separated path to the document field
+     * @param filter - comparison operator object
+     * @returns the same `Query` for chaining
+     * @example
+     * ```ts
+     * const q = new Query().where('age', { $gt: 18 });
+     * ```
+     */
+    where(field: string, filter: FilterOperators): this;
+    /**
+     * Add an `$or` clause to the query.
+     * @param clauses - query groups where at least one must match
+     */
+    or(...clauses: QueryClauseInput[]): this;
+    /**
+     * Add an `$and` clause to the query.
+     * @param clauses - query groups where all must match
+     */
+    and(...clauses: QueryClauseInput[]): this;
+    /**
+     * Add a `$nor` clause to the query.
+     * @param clauses - query groups where none may match
+     */
+    nor(...clauses: QueryClauseInput[]): this;
+    /**
+     * Specify sorting for the result set.
+     * @param field - field to sort by
+     * @param direction - `asc` or `desc` (defaults to `asc`)
+     * @example
+     * ```ts
+     * const q = new Query().sortBy('name', 'desc');
+     * ```
+     */
+    sortBy(field: string, direction?: "asc" | "desc"): this;
+    /**
+     * Set an offset and limit for pagination.
+     * @param offset - number of documents to skip
+     * @param limit - maximum number of documents to return
+     * @example
+     * ```ts
+     * const q = new Query().sector(10, 5);
+     * ```
+     */
+    sector(offset?: number, limit?: number): this;
+    private addLogicalClause;
+}
+/**
+ * Shortcut helper that creates a new `Query` with a single
+ * `where` clause applied.
+ *
+ * @param field - field name to filter on
+ * @param filter - filter operator object
+ * @returns a `Query` instance ready to use
+ * @example
+ * ```ts
+ * bucket.list(where('age', { $lt: 30 }));
+ * ```
+ */
+export declare function where(field: string, filter: FilterOperators): Query;
+export {};

package/dist/query.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Query = void 0;
+exports.where = where;
+function isQuery(value) {
+    return value instanceof Query;
+}
+function toClause(value) {
+    if (isQuery(value)) {
+        return value.query.query ?? {};
+    }
+    return value;
+}
+/**
+ * Builder for query objects that can be used with bucket
+ * operations like `list`, `delete`, and `transform`.
+ *
+ * The class supports chaining to construct filters, sorting,
+ * and pagination (offset/limit).
+ */
+class Query {
+    _query = {};
+    static or(...clauses) {
+        return new Query().or(...clauses);
+    }
+    static and(...clauses) {
+        return new Query().and(...clauses);
+    }
+    static nor(...clauses) {
+        return new Query().nor(...clauses);
+    }
+    /**
+     * Return the raw query object to pass to the native layer.
+     */
+    get query() {
+        return this._query;
+    }
+    /**
+     * Add a filter condition for the specified field.
+     * @param field - dot-separated path to the document field
+     * @param filter - comparison operator object
+     * @returns the same `Query` for chaining
+     * @example
+     * ```ts
+     * const q = new Query().where('age', { $gt: 18 });
+     * ```
+     */
+    where(field, filter) {
+        if (!this._query.query) {
+            this._query.query = {};
+        }
+        this._query.query[field] = filter;
+        return this;
+    }
+    /**
+     * Add an `$or` clause to the query.
+     * @param clauses - query groups where at least one must match
+     */
+    or(...clauses) {
+        return this.addLogicalClause("$or", clauses);
+    }
+    /**
+     * Add an `$and` clause to the query.
+     * @param clauses - query groups where all must match
+     */
+    and(...clauses) {
+        return this.addLogicalClause("$and", clauses);
+    }
+    /**
+     * Add a `$nor` clause to the query.
+     * @param clauses - query groups where none may match
+     */
+    nor(...clauses) {
+        return this.addLogicalClause("$nor", clauses);
+    }
+    /**
+     * Specify sorting for the result set.
+     * @param field - field to sort by
+     * @param direction - `asc` or `desc` (defaults to `asc`)
+     * @example
+     * ```ts
+     * const q = new Query().sortBy('name', 'desc');
+     * ```
+     */
+    sortBy(field, direction = "asc") {
+        this._query.sort = direction === "asc" ? { asc: field } : { desc: field };
+        return this;
+    }
+    /**
+     * Set an offset and limit for pagination.
+     * @param offset - number of documents to skip
+     * @param limit - maximum number of documents to return
+     * @example
+     * ```ts
+     * const q = new Query().sector(10, 5);
+     * ```
+     */
+    sector(offset, limit) {
+        this._query.sector = { offset, limit };
+        return this;
+    }
+    addLogicalClause(operator, clauses) {
+        if (!this._query.query) {
+            this._query.query = {};
+        }
+        this._query.query[operator] = clauses.map(toClause);
+        return this;
+    }
+}
+exports.Query = Query;
+/**
+ * Shortcut helper that creates a new `Query` with a single
+ * `where` clause applied.
+ *
+ * @param field - field name to filter on
+ * @param filter - filter operator object
+ * @returns a `Query` instance ready to use
+ * @example
+ * ```ts
+ * bucket.list(where('age', { $lt: 30 }));
+ * ```
+ */
+function where(field, filter) {
+    return new Query().where(field, filter);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "albedo-node",
-  "version": "0.8.2",
+  "version": "0.9.3",
   "description": "High-performance embedded database for Node.js with native bindings, BSON support, indexing, and replication",
   "keywords": [
     "albedo",
@@ -35,4 +35,4 @@
   "dependencies": {
     "detect-libc": "^2.1.2"
   }
-}
+}

package/scripts/publish.ts

@@ -18,7 +18,9 @@ async function main() {
   const buildRes = await $`bun run build`;
   if (buildRes.exitCode !== 0) throw new Error("build failed");
 
-  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), `${name.replace("/", "-")}-`));
+  const tmp = fs.mkdtempSync(
+    path.join(os.tmpdir(), `${name.replace("/", "-")}-`),
+  );
   console.log(`📦 Preparing publish directory: ${tmp}`);
 
   function copyOrFail(rel: string) {
@@ -41,17 +43,24 @@ async function main() {
   const publishPkg = { ...pkg } as Record<string, any>;
   delete publishPkg.devDependencies;
   delete publishPkg.scripts;
-  publishPkg.files = Array.from(new Set([...(publishPkg.files || []), "dist", "native"]));
+  publishPkg.files = Array.from(
+    new Set([...(publishPkg.files || []), "dist", "native"]),
+  );
   if (publishPkg.private) delete publishPkg.private;
 
-  fs.writeFileSync(path.join(tmp, "package.json"), JSON.stringify(publishPkg, null, 2) + "\n");
+  fs.writeFileSync(
+    path.join(tmp, "package.json"),
+    JSON.stringify(publishPkg, null, 2) + "\n",
+  );
 
   console.log("📋 Files staged for publish:");
   const lsRes = await $`ls -1`.cwd(tmp);
   if (lsRes.exitCode === 0) console.log(String(lsRes.stdout || "").trim());
 
   if (dry) {
-    console.log("⚠️ Dry run — skipping npm publish. Use --no-dry-run to actually publish.");
+    console.log(
+      "⚠️ Dry run — skipping npm publish. Use --no-dry-run to actually publish.",
+    );
   } else {
     const packOnly = process.argv.includes("--pack-only");
 
@@ -61,9 +70,12 @@ async function main() {
       console.error(String(packRes.stderr || packRes.stdout || ""));
       throw new Error(`bun pm pack failed (${packRes.exitCode})`);
     }
-    console.log("✅ Package tarball created:", packRes.stdout.toString('utf8'));
+    console.log("✅ Package tarball created:", packRes.stdout.toString("utf8"));
 
-    const tarballName = String(packRes.stdout || packRes.stderr || "").trim().split(/\r?\n/).pop();
+    const tarballName = String(packRes.stdout || packRes.stderr || "")
+      .trim()
+      .split(/\r?\n/)
+      .pop();
     const tarballPath = path.join(tmp, tarballName || "package.tgz");
     console.log(`📦 Packaged: ${tarballPath}`);
 
@@ -71,7 +83,8 @@ async function main() {
       console.log("ℹ️ --pack-only provided; skipping publish.");
     } else {
       console.log("➡️ Publishing tarball with bun publish...");
-      const publishRes = await $`npm publishbun --access public ${tarballPath}`.cwd(root);
+      const publishRes =
+        await $`npm publish --access public ${tarballPath}`.cwd(root);
       if (publishRes.exitCode !== 0) {
         console.error(String(publishRes.stderr || publishRes.stdout || ""));
         throw new Error(`bun publish failed (${publishRes.exitCode})`);