@kedaruma/revlm-client 1.0.0 → 1.0.2

package/dist/index.d.mts

@@ -0,0 +1,179 @@
+import { Timestamp, Long } from 'bson';
+
+type FindOneOptions = {
+    readonly projection?: Record<string, unknown>;
+    readonly sort?: Record<string, unknown>;
+};
+type FindOptions = FindOneOptions & {
+    readonly limit?: number;
+};
+type FindOneAndModifyOptions = FindOneOptions & {
+    readonly upsert?: boolean;
+    readonly returnNewDocument?: boolean;
+};
+type CountOptions = {
+    readonly limit?: number;
+};
+type UpdateOptions = {
+    readonly upsert?: boolean;
+    readonly arrayFilters?: Filter[];
+};
+type Document<IdType = unknown> = {
+    _id: IdType;
+};
+type NewDocument<T extends Document> = Omit<T, "_id"> & Partial<Pick<T, "_id">>;
+type InsertOneResult<IdType> = {
+    readonly insertedId: IdType;
+};
+type InsertManyResult<IdType> = {
+    readonly insertedIds: IdType[];
+};
+type DeleteResult = {
+    readonly deletedCount: number;
+};
+type UpdateResult<IdType> = {
+    readonly matchedCount: number;
+    readonly modifiedCount: number;
+    readonly upsertedId?: IdType;
+};
+type Filter = Record<string, unknown>;
+type Update = Record<string, unknown>;
+type AggregatePipelineStage = Record<string, unknown>;
+type OperationType = "insert" | "delete" | "replace" | "update" | "drop" | "rename" | "dropDatabase" | "invalidate";
+type DocumentNamespace = {
+    db: string;
+    coll: string;
+};
+type UpdateDescription = {
+    updatedFields: Record<string, unknown>;
+    removedFields: string[];
+};
+type ChangeEventId = unknown;
+type DocumentKey<IdType> = {
+    _id: IdType;
+} & Record<string, unknown>;
+type BaseChangeEvent<T extends OperationType> = {
+    _id: ChangeEventId;
+    operationType: T;
+    clusterTime: Timestamp;
+    txnNumber?: Long;
+    lsid?: Record<string, unknown>;
+};
+type InsertEvent<T extends Document> = {
+    ns: DocumentNamespace;
+    documentKey: DocumentKey<T["_id"]>;
+    fullDocument: T;
+} & BaseChangeEvent<"insert">;
+type UpdateEvent<T extends Document> = {
+    ns: DocumentNamespace;
+    documentKey: DocumentKey<T["_id"]>;
+    updateDescription: UpdateDescription;
+    fullDocument?: T;
+} & BaseChangeEvent<"update">;
+type ReplaceEvent<T extends Document> = {
+    ns: DocumentNamespace;
+    documentKey: DocumentKey<T["_id"]>;
+    fullDocument: T;
+} & BaseChangeEvent<"replace">;
+type DeleteEvent<T extends Document> = {
+    ns: DocumentNamespace;
+    documentKey: DocumentKey<T["_id"]>;
+} & BaseChangeEvent<"delete">;
+type DropEvent = {
+    ns: DocumentNamespace;
+} & BaseChangeEvent<"drop">;
+type RenameEvent = {
+    ns: DocumentNamespace;
+    to: DocumentNamespace;
+} & BaseChangeEvent<"rename">;
+type DropDatabaseEvent = {
+    ns: Omit<DocumentNamespace, "coll">;
+} & BaseChangeEvent<"dropDatabase">;
+type InvalidateEvent = BaseChangeEvent<"invalidate">;
+type ChangeEvent<T extends Document> = InsertEvent<T> | UpdateEvent<T> | ReplaceEvent<T> | DeleteEvent<T> | DropEvent | RenameEvent | DropDatabaseEvent | InvalidateEvent;
+type WatchOptionsIds<T extends Document> = {
+    ids: T["_id"][];
+    filter?: never;
+};
+type WatchOptionsFilter = {
+    ids?: never;
+    filter: Filter;
+};
+
+declare class RevlmCollection<T extends Document = Document> {
+    private _revlm;
+    private _dbName;
+    private _collection;
+    constructor(collection: string, dbName: string, revlm: Revlm);
+    get name(): string;
+    private vg;
+    find(filter?: Filter, options?: FindOptions): Promise<T[]>;
+    findOne(filter?: Filter, options?: FindOneOptions): Promise<T | null>;
+    findOneAndUpdate(filter: Filter, update: Update, options?: FindOneAndModifyOptions): Promise<T | null>;
+    findOneAndReplace(filter: Filter, replacement: unknown, options?: FindOneAndModifyOptions): Promise<T | null>;
+    findOneAndDelete(filter?: Filter, options?: FindOneOptions): Promise<T | null>;
+    aggregate(pipeline: AggregatePipelineStage[]): Promise<unknown>;
+    count(filter?: Filter, options?: CountOptions): Promise<number>;
+    insertOne(document: NewDocument<T>): Promise<InsertOneResult<T["_id"]>>;
+    insertMany(documents: NewDocument<T>[]): Promise<InsertManyResult<T["_id"]>>;
+    deleteOne(filter?: Filter): Promise<DeleteResult>;
+    deleteMany(filter?: Filter): Promise<DeleteResult>;
+    updateOne(filter: Filter, update: Update, options?: UpdateOptions): Promise<UpdateResult<T["_id"]>>;
+    updateMany(filter: Filter, update: Update, options?: UpdateOptions): Promise<UpdateResult<T["_id"]>>;
+    watch(options?: WatchOptionsIds<T> | WatchOptionsFilter): AsyncGenerator<ChangeEvent<T>>;
+}
+
+declare class RevlmDBDatabase {
+    private _revlm;
+    private _dbName;
+    constructor(dbName: string, revlm: Revlm);
+    collection<T extends Document = Document>(collection: string): RevlmCollection<T>;
+}
+
+type RevlmOptions = {
+    fetchImpl?: typeof fetch;
+    defaultHeaders?: Record<string, string>;
+    provisionalEnabled?: boolean;
+    provisionalAuthSecretMaster?: string;
+    provisionalAuthDomain?: string;
+    autoSetToken?: boolean;
+};
+type RevlmResponse<T = any> = {
+    ok: boolean;
+    error?: string;
+    token?: string;
+    user?: any;
+    result?: T;
+    [k: string]: any;
+};
+declare class Revlm {
+    baseUrl: string;
+    fetchImpl: typeof fetch;
+    defaultHeaders: Record<string, string>;
+    private _token;
+    private provisionalEnabled;
+    private provisionalAuthSecretMaster;
+    private provisionalAuthDomain;
+    private autoSetToken;
+    constructor(baseUrl: string, opts?: RevlmOptions);
+    setToken(token: string): void;
+    getToken(): string | undefined;
+    clearToken(): void;
+    logout(): void;
+    refreshToken(): Promise<RevlmResponse>;
+    verifyToken(): Promise<RevlmResponse>;
+    private makeHeaders;
+    private parseResponse;
+    private request;
+    login(authId: string, password: string): Promise<RevlmResponse<any>>;
+    provisionalLogin(authId: string): Promise<RevlmResponse<any>>;
+    registerUser(user: any, password: string): Promise<RevlmResponse<any>>;
+    deleteUser(params: {
+        _id?: any;
+        authId?: string;
+    }): Promise<RevlmResponse<any>>;
+    revlmGate(payload: any): Promise<RevlmResponse<any>>;
+    db(dbName: string): RevlmDBDatabase;
+}
+
+export { Revlm, type RevlmOptions, type RevlmResponse };

package/dist/index.d.ts

@@ -0,0 +1,179 @@
+import { Timestamp, Long } from 'bson';
+
+type FindOneOptions = {
+    readonly projection?: Record<string, unknown>;
+    readonly sort?: Record<string, unknown>;
+};
+type FindOptions = FindOneOptions & {
+    readonly limit?: number;
+};
+type FindOneAndModifyOptions = FindOneOptions & {
+    readonly upsert?: boolean;
+    readonly returnNewDocument?: boolean;
+};
+type CountOptions = {
+    readonly limit?: number;
+};
+type UpdateOptions = {
+    readonly upsert?: boolean;
+    readonly arrayFilters?: Filter[];
+};
+type Document<IdType = unknown> = {
+    _id: IdType;
+};
+type NewDocument<T extends Document> = Omit<T, "_id"> & Partial<Pick<T, "_id">>;
+type InsertOneResult<IdType> = {
+    readonly insertedId: IdType;
+};
+type InsertManyResult<IdType> = {
+    readonly insertedIds: IdType[];
+};
+type DeleteResult = {
+    readonly deletedCount: number;
+};
+type UpdateResult<IdType> = {
+    readonly matchedCount: number;
+    readonly modifiedCount: number;
+    readonly upsertedId?: IdType;
+};
+type Filter = Record<string, unknown>;
+type Update = Record<string, unknown>;
+type AggregatePipelineStage = Record<string, unknown>;
+type OperationType = "insert" | "delete" | "replace" | "update" | "drop" | "rename" | "dropDatabase" | "invalidate";
+type DocumentNamespace = {
+    db: string;
+    coll: string;
+};
+type UpdateDescription = {
+    updatedFields: Record<string, unknown>;
+    removedFields: string[];
+};
+type ChangeEventId = unknown;
+type DocumentKey<IdType> = {
+    _id: IdType;
+} & Record<string, unknown>;
+type BaseChangeEvent<T extends OperationType> = {
+    _id: ChangeEventId;
+    operationType: T;
+    clusterTime: Timestamp;
+    txnNumber?: Long;
+    lsid?: Record<string, unknown>;
+};
+type InsertEvent<T extends Document> = {
+    ns: DocumentNamespace;
+    documentKey: DocumentKey<T["_id"]>;
+    fullDocument: T;
+} & BaseChangeEvent<"insert">;
+type UpdateEvent<T extends Document> = {
+    ns: DocumentNamespace;
+    documentKey: DocumentKey<T["_id"]>;
+    updateDescription: UpdateDescription;
+    fullDocument?: T;
+} & BaseChangeEvent<"update">;
+type ReplaceEvent<T extends Document> = {
+    ns: DocumentNamespace;
+    documentKey: DocumentKey<T["_id"]>;
+    fullDocument: T;
+} & BaseChangeEvent<"replace">;
+type DeleteEvent<T extends Document> = {
+    ns: DocumentNamespace;
+    documentKey: DocumentKey<T["_id"]>;
+} & BaseChangeEvent<"delete">;
+type DropEvent = {
+    ns: DocumentNamespace;
+} & BaseChangeEvent<"drop">;
+type RenameEvent = {
+    ns: DocumentNamespace;
+    to: DocumentNamespace;
+} & BaseChangeEvent<"rename">;
+type DropDatabaseEvent = {
+    ns: Omit<DocumentNamespace, "coll">;
+} & BaseChangeEvent<"dropDatabase">;
+type InvalidateEvent = BaseChangeEvent<"invalidate">;
+type ChangeEvent<T extends Document> = InsertEvent<T> | UpdateEvent<T> | ReplaceEvent<T> | DeleteEvent<T> | DropEvent | RenameEvent | DropDatabaseEvent | InvalidateEvent;
+type WatchOptionsIds<T extends Document> = {
+    ids: T["_id"][];
+    filter?: never;
+};
+type WatchOptionsFilter = {
+    ids?: never;
+    filter: Filter;
+};
+
+declare class RevlmCollection<T extends Document = Document> {
+    private _revlm;
+    private _dbName;
+    private _collection;
+    constructor(collection: string, dbName: string, revlm: Revlm);
+    get name(): string;
+    private vg;
+    find(filter?: Filter, options?: FindOptions): Promise<T[]>;
+    findOne(filter?: Filter, options?: FindOneOptions): Promise<T | null>;
+    findOneAndUpdate(filter: Filter, update: Update, options?: FindOneAndModifyOptions): Promise<T | null>;
+    findOneAndReplace(filter: Filter, replacement: unknown, options?: FindOneAndModifyOptions): Promise<T | null>;
+    findOneAndDelete(filter?: Filter, options?: FindOneOptions): Promise<T | null>;
+    aggregate(pipeline: AggregatePipelineStage[]): Promise<unknown>;
+    count(filter?: Filter, options?: CountOptions): Promise<number>;
+    insertOne(document: NewDocument<T>): Promise<InsertOneResult<T["_id"]>>;
+    insertMany(documents: NewDocument<T>[]): Promise<InsertManyResult<T["_id"]>>;
+    deleteOne(filter?: Filter): Promise<DeleteResult>;
+    deleteMany(filter?: Filter): Promise<DeleteResult>;
+    updateOne(filter: Filter, update: Update, options?: UpdateOptions): Promise<UpdateResult<T["_id"]>>;
+    updateMany(filter: Filter, update: Update, options?: UpdateOptions): Promise<UpdateResult<T["_id"]>>;
+    watch(options?: WatchOptionsIds<T> | WatchOptionsFilter): AsyncGenerator<ChangeEvent<T>>;
+}
+
+declare class RevlmDBDatabase {
+    private _revlm;
+    private _dbName;
+    constructor(dbName: string, revlm: Revlm);
+    collection<T extends Document = Document>(collection: string): RevlmCollection<T>;
+}
+
+type RevlmOptions = {
+    fetchImpl?: typeof fetch;
+    defaultHeaders?: Record<string, string>;
+    provisionalEnabled?: boolean;
+    provisionalAuthSecretMaster?: string;
+    provisionalAuthDomain?: string;
+    autoSetToken?: boolean;
+};
+type RevlmResponse<T = any> = {
+    ok: boolean;
+    error?: string;
+    token?: string;
+    user?: any;
+    result?: T;
+    [k: string]: any;
+};
+declare class Revlm {
+    baseUrl: string;
+    fetchImpl: typeof fetch;
+    defaultHeaders: Record<string, string>;
+    private _token;
+    private provisionalEnabled;
+    private provisionalAuthSecretMaster;
+    private provisionalAuthDomain;
+    private autoSetToken;
+    constructor(baseUrl: string, opts?: RevlmOptions);
+    setToken(token: string): void;
+    getToken(): string | undefined;
+    clearToken(): void;
+    logout(): void;
+    refreshToken(): Promise<RevlmResponse>;
+    verifyToken(): Promise<RevlmResponse>;
+    private makeHeaders;
+    private parseResponse;
+    private request;
+    login(authId: string, password: string): Promise<RevlmResponse<any>>;
+    provisionalLogin(authId: string): Promise<RevlmResponse<any>>;
+    registerUser(user: any, password: string): Promise<RevlmResponse<any>>;
+    deleteUser(params: {
+        _id?: any;
+        authId?: string;
+    }): Promise<RevlmResponse<any>>;
+    revlmGate(payload: any): Promise<RevlmResponse<any>>;
+    db(dbName: string): RevlmDBDatabase;
+}
+
+export { Revlm, type RevlmOptions, type RevlmResponse };

package/dist/index.js

@@ -0,0 +1,276 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Revlm: () => Revlm
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/Revlm.ts
+var import_bson = require("bson");
+var import_revlm_shared = require("@kedaruma/revlm-shared");
+
+// src/RevlmCollection.ts
+var RevlmCollection = class {
+  _revlm;
+  _dbName;
+  _collection;
+  constructor(collection, dbName, revlm) {
+    this._collection = collection;
+    this._dbName = dbName;
+    this._revlm = revlm;
+  }
+  get name() {
+    return this._collection;
+  }
+  // Helper to call server revlm-gate and return parsed result or throw on error
+  async vg(method, params = {}) {
+    const payload = { db: this._dbName, collection: this._collection, method, ...params };
+    const res = await this._revlm.revlmGate(payload);
+    if (!res || !res.ok) {
+      const errMsg = res && (res.error || res.reason) ? res.error || res.reason : "revlm-gate error";
+      const e = new Error(String(errMsg));
+      e.response = res;
+      throw e;
+    }
+    return res.result;
+  }
+  async find(filter, options) {
+    const result = await this.vg("find", { filter: filter || {}, options: options || {} });
+    return Array.isArray(result) ? result : result || [];
+  }
+  async findOne(filter, options) {
+    const result = await this.vg("findOne", { filter: filter || {}, options: options || {} });
+    return result === void 0 ? null : result;
+  }
+  async findOneAndUpdate(filter, update, options) {
+    const result = await this.vg("findOneAndUpdate", { filter, update, options: options || {} });
+    return result && (result.value ?? result);
+  }
+  async findOneAndReplace(filter, replacement, options) {
+    const result = await this.vg("findOneAndReplace", { filter, replacement, options: options || {} });
+    return result && (result.value ?? result);
+  }
+  async findOneAndDelete(filter, options) {
+    const result = await this.vg("findOneAndDelete", { filter: filter || {}, options: options || {} });
+    return result && (result.value ?? result);
+  }
+  async aggregate(pipeline) {
+    return await this.vg("aggregate", { pipeline });
+  }
+  async count(filter, options) {
+    const result = await this.vg("count", { filter: filter || {}, options: options || {} });
+    return Number(result || 0);
+  }
+  async insertOne(document) {
+    const result = await this.vg("insertOne", { document });
+    return result;
+  }
+  async insertMany(documents) {
+    const result = await this.vg("insertMany", { documents });
+    return result;
+  }
+  async deleteOne(filter) {
+    const result = await this.vg("deleteOne", { filter: filter || {} });
+    return result;
+  }
+  async deleteMany(filter) {
+    const result = await this.vg("deleteMany", { filter: filter || {} });
+    return result;
+  }
+  async updateOne(filter, update, options) {
+    const result = await this.vg("updateOne", { filter, update, options: options || {} });
+    return result;
+  }
+  async updateMany(filter, update, options) {
+    const result = await this.vg("updateMany", { filter, update, options: options || {} });
+    return result;
+  }
+  // single watch implementation with optional options
+  async *watch(options) {
+    const arr = await this.vg("watch", { options: options || {} }) || [];
+    for (const it of Array.isArray(arr) ? arr : []) {
+      yield it;
+    }
+  }
+};
+
+// src/RevlmDBDatabase.ts
+var RevlmDBDatabase = class {
+  _revlm;
+  _dbName;
+  constructor(dbName, revlm) {
+    this._dbName = dbName;
+    this._revlm = revlm;
+  }
+  collection(collection) {
+    return new RevlmCollection(collection, this._dbName, this._revlm);
+  }
+};
+
+// src/Revlm.ts
+var Revlm = class {
+  baseUrl;
+  fetchImpl;
+  defaultHeaders;
+  _token;
+  provisionalEnabled;
+  provisionalAuthSecretMaster;
+  provisionalAuthDomain;
+  autoSetToken;
+  constructor(baseUrl, opts = {}) {
+    if (!baseUrl) throw new Error("baseUrl is required");
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.fetchImpl = opts.fetchImpl || (typeof fetch !== "undefined" ? fetch : void 0);
+    this.defaultHeaders = opts.defaultHeaders || {};
+    this.provisionalEnabled = opts.provisionalEnabled || false;
+    this.provisionalAuthSecretMaster = opts.provisionalAuthSecretMaster || "";
+    this.provisionalAuthDomain = opts.provisionalAuthDomain || "";
+    this.autoSetToken = opts.autoSetToken ?? true;
+    if (!this.fetchImpl) {
+      throw new Error("No fetch implementation available. Provide fetchImpl in options or run in Node 18+ with global fetch.");
+    }
+  }
+  setToken(token) {
+    this._token = token;
+  }
+  getToken() {
+    return this._token;
+  }
+  clearToken() {
+    this._token = void 0;
+  }
+  // Logout clears client-side token (simple, synchronous)
+  logout() {
+    this.clearToken();
+  }
+  // Call server to refresh token. Uses Authorization header with current token.
+  // On success, if autoSetToken is true and res.token is set, update the client token.
+  async refreshToken() {
+    if (!this._token) return { ok: false, error: "No token set" };
+    const res = await this.request("/refresh-token", "POST");
+    if (this.autoSetToken && res && res.ok && res.token) {
+      this.setToken(res.token);
+    }
+    return res;
+  }
+  // Verify current token with server. If invalid/expired, clear local token.
+  async verifyToken() {
+    if (!this._token) return { ok: false, error: "No token set" };
+    const res = await this.request("/verify-token", "POST");
+    const reason = res.reason || res.error;
+    if (res && !res.ok) {
+      if (reason === "invalid_token" || reason === "token_expired" || reason === "no_token" || res.status === 401 || res.status === 403) {
+        this.clearToken();
+      }
+    }
+    return res;
+  }
+  makeHeaders(hasBody) {
+    const headers = {
+      Accept: "application/ejson",
+      ...this.defaultHeaders
+    };
+    if (hasBody) {
+      headers["Content-Type"] = "application/ejson";
+    }
+    if (this._token) {
+      headers["Authorization"] = `Bearer ${this._token}`;
+    }
+    return headers;
+  }
+  async parseResponse(res) {
+    const text = await res.text();
+    if (!text) return null;
+    try {
+      return import_bson.EJSON.parse(text);
+    } catch (e) {
+    }
+    try {
+      return JSON.parse(text);
+    } catch (e) {
+      return text;
+    }
+  }
+  async request(path, method = "POST", body) {
+    const url = path.startsWith("http") ? path : `${this.baseUrl}${path.startsWith("/") ? "" : "/"}${path}`;
+    const hasBody = body !== void 0;
+    const headers = this.makeHeaders(hasBody);
+    let serializedBody;
+    if (hasBody) {
+      serializedBody = import_bson.EJSON.stringify(body);
+    }
+    try {
+      const res = await this.fetchImpl(url, {
+        method,
+        headers,
+        body: serializedBody
+      });
+      const parsed = await this.parseResponse(res);
+      const out = parsed && typeof parsed === "object" ? parsed : { ok: res.ok, result: parsed };
+      out.status = res.status;
+      return out;
+    } catch (err) {
+      return { ok: false, error: err?.message || String(err) };
+    }
+  }
+  async login(authId, password) {
+    if (!authId || !password) throw new Error("authId and password are required");
+    const res = await this.request("/login", "POST", { authId, password });
+    if (this.autoSetToken && res && res.ok && res.token) {
+      this.setToken(res.token);
+    }
+    return res;
+  }
+  async provisionalLogin(authId) {
+    if (!this.provisionalEnabled) {
+      throw new Error("provisional login is disabled by client configuration");
+    }
+    if (!authId) throw new Error("authId is required");
+    const provisionalClient = new import_revlm_shared.AuthClient({ secretMaster: this.provisionalAuthSecretMaster, authDomain: this.provisionalAuthDomain });
+    const provisionalPassword = await provisionalClient.producePassword(String(Date.now() * 1e3));
+    const res = await this.request("/provisional-login", "POST", { authId, password: provisionalPassword });
+    if (this.autoSetToken && res && res.ok && res.token) {
+      this.setToken(res.token);
+    }
+    return res;
+  }
+  async registerUser(user, password) {
+    if (!user) throw new Error("user is required");
+    if (!password) throw new Error("password is required");
+    return this.request("/registerUser", "POST", { user, password });
+  }
+  async deleteUser(params) {
+    if (!params || !params._id && !params.authId) throw new Error("Either _id or authId must be provided");
+    return this.request("/deleteUser", "POST", params);
+  }
+  async revlmGate(payload) {
+    if (!payload || typeof payload !== "object") throw new Error("payload object is required");
+    return this.request("/revlm-gate", "POST", payload);
+  }
+  db(dbName) {
+    return new RevlmDBDatabase(dbName, this);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Revlm
+});

package/dist/index.mjs

@@ -0,0 +1,249 @@
+// src/Revlm.ts
+import { EJSON } from "bson";
+import { AuthClient } from "@kedaruma/revlm-shared";
+
+// src/RevlmCollection.ts
+var RevlmCollection = class {
+  _revlm;
+  _dbName;
+  _collection;
+  constructor(collection, dbName, revlm) {
+    this._collection = collection;
+    this._dbName = dbName;
+    this._revlm = revlm;
+  }
+  get name() {
+    return this._collection;
+  }
+  // Helper to call server revlm-gate and return parsed result or throw on error
+  async vg(method, params = {}) {
+    const payload = { db: this._dbName, collection: this._collection, method, ...params };
+    const res = await this._revlm.revlmGate(payload);
+    if (!res || !res.ok) {
+      const errMsg = res && (res.error || res.reason) ? res.error || res.reason : "revlm-gate error";
+      const e = new Error(String(errMsg));
+      e.response = res;
+      throw e;
+    }
+    return res.result;
+  }
+  async find(filter, options) {
+    const result = await this.vg("find", { filter: filter || {}, options: options || {} });
+    return Array.isArray(result) ? result : result || [];
+  }
+  async findOne(filter, options) {
+    const result = await this.vg("findOne", { filter: filter || {}, options: options || {} });
+    return result === void 0 ? null : result;
+  }
+  async findOneAndUpdate(filter, update, options) {
+    const result = await this.vg("findOneAndUpdate", { filter, update, options: options || {} });
+    return result && (result.value ?? result);
+  }
+  async findOneAndReplace(filter, replacement, options) {
+    const result = await this.vg("findOneAndReplace", { filter, replacement, options: options || {} });
+    return result && (result.value ?? result);
+  }
+  async findOneAndDelete(filter, options) {
+    const result = await this.vg("findOneAndDelete", { filter: filter || {}, options: options || {} });
+    return result && (result.value ?? result);
+  }
+  async aggregate(pipeline) {
+    return await this.vg("aggregate", { pipeline });
+  }
+  async count(filter, options) {
+    const result = await this.vg("count", { filter: filter || {}, options: options || {} });
+    return Number(result || 0);
+  }
+  async insertOne(document) {
+    const result = await this.vg("insertOne", { document });
+    return result;
+  }
+  async insertMany(documents) {
+    const result = await this.vg("insertMany", { documents });
+    return result;
+  }
+  async deleteOne(filter) {
+    const result = await this.vg("deleteOne", { filter: filter || {} });
+    return result;
+  }
+  async deleteMany(filter) {
+    const result = await this.vg("deleteMany", { filter: filter || {} });
+    return result;
+  }
+  async updateOne(filter, update, options) {
+    const result = await this.vg("updateOne", { filter, update, options: options || {} });
+    return result;
+  }
+  async updateMany(filter, update, options) {
+    const result = await this.vg("updateMany", { filter, update, options: options || {} });
+    return result;
+  }
+  // single watch implementation with optional options
+  async *watch(options) {
+    const arr = await this.vg("watch", { options: options || {} }) || [];
+    for (const it of Array.isArray(arr) ? arr : []) {
+      yield it;
+    }
+  }
+};
+
+// src/RevlmDBDatabase.ts
+var RevlmDBDatabase = class {
+  _revlm;
+  _dbName;
+  constructor(dbName, revlm) {
+    this._dbName = dbName;
+    this._revlm = revlm;
+  }
+  collection(collection) {
+    return new RevlmCollection(collection, this._dbName, this._revlm);
+  }
+};
+
+// src/Revlm.ts
+var Revlm = class {
+  baseUrl;
+  fetchImpl;
+  defaultHeaders;
+  _token;
+  provisionalEnabled;
+  provisionalAuthSecretMaster;
+  provisionalAuthDomain;
+  autoSetToken;
+  constructor(baseUrl, opts = {}) {
+    if (!baseUrl) throw new Error("baseUrl is required");
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.fetchImpl = opts.fetchImpl || (typeof fetch !== "undefined" ? fetch : void 0);
+    this.defaultHeaders = opts.defaultHeaders || {};
+    this.provisionalEnabled = opts.provisionalEnabled || false;
+    this.provisionalAuthSecretMaster = opts.provisionalAuthSecretMaster || "";
+    this.provisionalAuthDomain = opts.provisionalAuthDomain || "";
+    this.autoSetToken = opts.autoSetToken ?? true;
+    if (!this.fetchImpl) {
+      throw new Error("No fetch implementation available. Provide fetchImpl in options or run in Node 18+ with global fetch.");
+    }
+  }
+  setToken(token) {
+    this._token = token;
+  }
+  getToken() {
+    return this._token;
+  }
+  clearToken() {
+    this._token = void 0;
+  }
+  // Logout clears client-side token (simple, synchronous)
+  logout() {
+    this.clearToken();
+  }
+  // Call server to refresh token. Uses Authorization header with current token.
+  // On success, if autoSetToken is true and res.token is set, update the client token.
+  async refreshToken() {
+    if (!this._token) return { ok: false, error: "No token set" };
+    const res = await this.request("/refresh-token", "POST");
+    if (this.autoSetToken && res && res.ok && res.token) {
+      this.setToken(res.token);
+    }
+    return res;
+  }
+  // Verify current token with server. If invalid/expired, clear local token.
+  async verifyToken() {
+    if (!this._token) return { ok: false, error: "No token set" };
+    const res = await this.request("/verify-token", "POST");
+    const reason = res.reason || res.error;
+    if (res && !res.ok) {
+      if (reason === "invalid_token" || reason === "token_expired" || reason === "no_token" || res.status === 401 || res.status === 403) {
+        this.clearToken();
+      }
+    }
+    return res;
+  }
+  makeHeaders(hasBody) {
+    const headers = {
+      Accept: "application/ejson",
+      ...this.defaultHeaders
+    };
+    if (hasBody) {
+      headers["Content-Type"] = "application/ejson";
+    }
+    if (this._token) {
+      headers["Authorization"] = `Bearer ${this._token}`;
+    }
+    return headers;
+  }
+  async parseResponse(res) {
+    const text = await res.text();
+    if (!text) return null;
+    try {
+      return EJSON.parse(text);
+    } catch (e) {
+    }
+    try {
+      return JSON.parse(text);
+    } catch (e) {
+      return text;
+    }
+  }
+  async request(path, method = "POST", body) {
+    const url = path.startsWith("http") ? path : `${this.baseUrl}${path.startsWith("/") ? "" : "/"}${path}`;
+    const hasBody = body !== void 0;
+    const headers = this.makeHeaders(hasBody);
+    let serializedBody;
+    if (hasBody) {
+      serializedBody = EJSON.stringify(body);
+    }
+    try {
+      const res = await this.fetchImpl(url, {
+        method,
+        headers,
+        body: serializedBody
+      });
+      const parsed = await this.parseResponse(res);
+      const out = parsed && typeof parsed === "object" ? parsed : { ok: res.ok, result: parsed };
+      out.status = res.status;
+      return out;
+    } catch (err) {
+      return { ok: false, error: err?.message || String(err) };
+    }
+  }
+  async login(authId, password) {
+    if (!authId || !password) throw new Error("authId and password are required");
+    const res = await this.request("/login", "POST", { authId, password });
+    if (this.autoSetToken && res && res.ok && res.token) {
+      this.setToken(res.token);
+    }
+    return res;
+  }
+  async provisionalLogin(authId) {
+    if (!this.provisionalEnabled) {
+      throw new Error("provisional login is disabled by client configuration");
+    }
+    if (!authId) throw new Error("authId is required");
+    const provisionalClient = new AuthClient({ secretMaster: this.provisionalAuthSecretMaster, authDomain: this.provisionalAuthDomain });
+    const provisionalPassword = await provisionalClient.producePassword(String(Date.now() * 1e3));
+    const res = await this.request("/provisional-login", "POST", { authId, password: provisionalPassword });
+    if (this.autoSetToken && res && res.ok && res.token) {
+      this.setToken(res.token);
+    }
+    return res;
+  }
+  async registerUser(user, password) {
+    if (!user) throw new Error("user is required");
+    if (!password) throw new Error("password is required");
+    return this.request("/registerUser", "POST", { user, password });
+  }
+  async deleteUser(params) {
+    if (!params || !params._id && !params.authId) throw new Error("Either _id or authId must be provided");
+    return this.request("/deleteUser", "POST", params);
+  }
+  async revlmGate(payload) {
+    if (!payload || typeof payload !== "object") throw new Error("payload object is required");
+    return this.request("/revlm-gate", "POST", payload);
+  }
+  db(dbName) {
+    return new RevlmDBDatabase(dbName, this);
+  }
+};
+export {
+  Revlm
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kedaruma/revlm-client",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "private": false,
   "description": "TypeScript client SDK for talking to the Revlm server replacement for MongoDB Realm.",
   "main": "dist/index.js",
@@ -29,13 +29,13 @@
   "dependencies": {
     "bson": "^6.10.4",
     "dotenv": "^17.2.3",
-    "@kedaruma/revlm-shared": "1.0.0"
+    "@kedaruma/revlm-shared": "1.0.2"
   },
   "devDependencies": {
     "tsup": "^8.5.1"
   },
   "scripts": {
-    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "build": "tsup src/index.ts --format cjs,esm --dts --tsconfig tsconfig.build.json",
     "clean": "rm -rf dist node_modules kedaruma-revlm-client-*.tgz",
     "test": "pnpm exec jest --config ../../jest.config.cjs packages/revlm-client/src/__tests__/ --runInBand --watchman=false --verbose"
   }