hide-a-bed 5.2.7 → 6.0.0-beta.0

package/types/output/schema/util.d.mts

@@ -0,0 +1,85 @@
+import { z } from 'zod';
+export declare const MergeNeedleOpts: z.ZodFunction<z.ZodTuple<readonly [z.ZodObject<{
+    backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    bindWithRetry: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    couch: z.ZodString;
+    initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
+        error: z.ZodOptional<z.ZodFunction<z.ZodArray<z.ZodAny>, z.ZodVoid>>;
+        warn: z.ZodOptional<z.ZodFunction<z.ZodArray<z.ZodAny>, z.ZodVoid>>;
+        info: z.ZodOptional<z.ZodFunction<z.ZodArray<z.ZodAny>, z.ZodVoid>>;
+        debug: z.ZodOptional<z.ZodFunction<z.ZodArray<z.ZodAny>, z.ZodVoid>>;
+    }, z.core.$strip>, z.ZodFunction<z.ZodArray<z.ZodAny>, z.ZodVoid>]>>;
+    maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    needleOpts: z.ZodOptional<z.ZodObject<{
+        json: z.ZodOptional<z.ZodBoolean>;
+        compressed: z.ZodOptional<z.ZodBoolean>;
+        follow_max: z.ZodOptional<z.ZodNumber>;
+        follow_set_cookie: z.ZodOptional<z.ZodBoolean>;
+        follow_set_referer: z.ZodOptional<z.ZodBoolean>;
+        follow: z.ZodOptional<z.ZodNumber>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+        read_timeout: z.ZodOptional<z.ZodNumber>;
+        parse_response: z.ZodOptional<z.ZodBoolean>;
+        decode: z.ZodOptional<z.ZodBoolean>;
+        parse_cookies: z.ZodOptional<z.ZodBoolean>;
+        cookies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        auth: z.ZodOptional<z.ZodEnum<{
+            auto: "auto";
+            digest: "digest";
+            basic: "basic";
+        }>>;
+        username: z.ZodOptional<z.ZodString>;
+        password: z.ZodOptional<z.ZodString>;
+        proxy: z.ZodOptional<z.ZodString>;
+        agent: z.ZodOptional<z.ZodAny>;
+        rejectUnauthorized: z.ZodOptional<z.ZodBoolean>;
+        output: z.ZodOptional<z.ZodString>;
+        parse: z.ZodOptional<z.ZodBoolean>;
+        multipart: z.ZodOptional<z.ZodBoolean>;
+        open_timeout: z.ZodOptional<z.ZodNumber>;
+        response_timeout: z.ZodOptional<z.ZodNumber>;
+        keepAlive: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    throwOnGetNotFound: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    useConsoleLogger: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    '~emitter': z.ZodOptional<z.ZodAny>;
+    '~normalizedLogger': z.ZodOptional<z.ZodAny>;
+}, z.core.$strict>, z.ZodObject<{
+    json: z.ZodBoolean;
+    headers: z.ZodRecord<z.ZodString, z.ZodString>;
+    parse_response: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>], null>, z.ZodObject<{
+    json: z.ZodOptional<z.ZodBoolean>;
+    compressed: z.ZodOptional<z.ZodBoolean>;
+    follow_max: z.ZodOptional<z.ZodNumber>;
+    follow_set_cookie: z.ZodOptional<z.ZodBoolean>;
+    follow_set_referer: z.ZodOptional<z.ZodBoolean>;
+    follow: z.ZodOptional<z.ZodNumber>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    read_timeout: z.ZodOptional<z.ZodNumber>;
+    parse_response: z.ZodOptional<z.ZodBoolean>;
+    decode: z.ZodOptional<z.ZodBoolean>;
+    parse_cookies: z.ZodOptional<z.ZodBoolean>;
+    cookies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    auth: z.ZodOptional<z.ZodEnum<{
+        auto: "auto";
+        digest: "digest";
+        basic: "basic";
+    }>>;
+    username: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+    proxy: z.ZodOptional<z.ZodString>;
+    agent: z.ZodOptional<z.ZodAny>;
+    rejectUnauthorized: z.ZodOptional<z.ZodBoolean>;
+    output: z.ZodOptional<z.ZodString>;
+    parse: z.ZodOptional<z.ZodBoolean>;
+    multipart: z.ZodOptional<z.ZodBoolean>;
+    open_timeout: z.ZodOptional<z.ZodNumber>;
+    response_timeout: z.ZodOptional<z.ZodNumber>;
+    keepAlive: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>>;
+export type MergeNeedleOptsSchema = z.infer<typeof MergeNeedleOpts>;
+//# sourceMappingURL=util.d.mts.map

package/types/output/schema/util.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.mts","sourceRoot":"","sources":["../../../schema/util.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAG1B,CAAA;AACF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA"}

package/types/output/tsdown.config.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("tsdown").UserConfig[];
+export default _default;
+//# sourceMappingURL=tsdown.config.d.ts.map

package/types/output/tsdown.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tsdown.config.d.ts","sourceRoot":"","sources":["../../tsdown.config.ts"],"names":[],"mappings":";AAEA,wBAaE"}

package/types/output/types/standard-schema.d.ts

@@ -0,0 +1,60 @@
+/** The Standard Schema interface. */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+    /** The Standard Schema properties. */
+    readonly '~standard': StandardSchemaV1.Props<Input, Output>;
+}
+export declare namespace StandardSchemaV1 {
+    /** The Standard Schema properties interface. */
+    interface Props<Input = unknown, Output = Input> {
+        /** The version number of the standard. */
+        readonly version: 1;
+        /** The vendor name of the schema library. */
+        readonly vendor: string;
+        /** Validates unknown input values. */
+        readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+        /** Inferred types associated with the schema. */
+        readonly types?: Types<Input, Output> | undefined;
+    }
+    /** The result interface of the validate function. */
+    type Result<Output> = SuccessResult<Output> | FailureResult;
+    /** The result interface if validation succeeds. */
+    interface SuccessResult<Output> {
+        /** The typed output value. */
+        readonly value: Output;
+        /** A falsy value for `issues` indicates success. */
+        readonly issues?: undefined;
+    }
+    interface Options {
+        /** Explicit support for additional vendor-specific parameters, if needed. */
+        readonly libraryOptions?: Record<string, unknown> | undefined;
+    }
+    /** The result interface if validation fails. */
+    interface FailureResult {
+        /** The issues of failed validation. */
+        readonly issues: ReadonlyArray<Issue>;
+    }
+    /** The issue interface of the failure output. */
+    interface Issue {
+        /** The error message of the issue. */
+        readonly message: string;
+        /** The path of the issue, if any. */
+        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+    }
+    /** The path segment interface of the issue. */
+    interface PathSegment {
+        /** The key representing a path segment. */
+        readonly key: PropertyKey;
+    }
+    /** The Standard Schema types interface. */
+    interface Types<Input = unknown, Output = Input> {
+        /** The input type of the schema. */
+        readonly input: Input;
+        /** The output type of the schema. */
+        readonly output: Output;
+    }
+    /** Infers the input type of a Standard Schema. */
+    type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
+    /** Infers the output type of a Standard Schema. */
+    type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
+}
+//# sourceMappingURL=standard-schema.d.ts.map

package/types/output/types/standard-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"standard-schema.d.ts","sourceRoot":"","sources":["../../standard-schema.ts"],"names":[],"mappings":"AAAA,qCAAqC;AACrC,MAAM,WAAW,gBAAgB,CAAC,KAAK,GAAG,OAAO,EAAE,MAAM,GAAG,KAAK;IAC/D,sCAAsC;IACtC,QAAQ,CAAC,WAAW,EAAE,gBAAgB,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;CAC5D;AAED,MAAM,CAAC,OAAO,WAAW,gBAAgB,CAAC;IACxC,gDAAgD;IAChD,UAAiB,KAAK,CAAC,KAAK,GAAG,OAAO,EAAE,MAAM,GAAG,KAAK;QACpD,0CAA0C;QAC1C,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAA;QACnB,6CAA6C;QAC7C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;QACvB,sCAAsC;QACtC,QAAQ,CAAC,QAAQ,EAAE,CACjB,KAAK,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,gBAAgB,CAAC,OAAO,GAAG,SAAS,KAC3C,MAAM,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAA;QAC7C,iDAAiD;QACjD,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,SAAS,CAAA;KAClD;IAED,qDAAqD;IACrD,KAAY,MAAM,CAAC,MAAM,IAAI,aAAa,CAAC,MAAM,CAAC,GAAG,aAAa,CAAA;IAElE,mDAAmD;IACnD,UAAiB,aAAa,CAAC,MAAM;QACnC,8BAA8B;QAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;QACtB,oDAAoD;QACpD,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAA;KAC5B;IAED,UAAiB,OAAO;QACtB,6EAA6E;QAC7E,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAAA;KAC9D;IAED,gDAAgD;IAChD,UAAiB,aAAa;QAC5B,uCAAuC;QACvC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,KAAK,CAAC,CAAA;KACtC;IAED,iDAAiD;IACjD,UAAiB,KAAK;QACpB,sCAAsC;QACtC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;QACxB,qCAAqC;QACrC,QAAQ,CAAC,IAAI,CAAC,EAAE,aAAa,CAAC,WAAW,GAAG,WAAW,CAAC,GAAG,SAAS,CAAA;KACrE;IAED,+CAA+C;IAC/C,UAAiB,WAAW;QAC1B,2CAA2C;QAC3C,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAA;KAC1B;IAED,2CAA2C;IAC3C,UAAiB,KAAK,CAAC,KAAK,GAAG,OAAO,EAAE,MAAM,GAAG,KAAK;QACpD,oCAAoC;QACpC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;QACrB,qCAAqC;QACrC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;KACxB;IAED,kDAAkD;IAClD,KAAY,UAAU,CAAC,MAAM,SAAS,gBAAgB,IAAI,WAAW,CACnE,MAAM,CAAC,WAAW,CAAC,CAAC,OAAO,CAAC,CAC7B,CAAC,OAAO,CAAC,CAAA;IAEV,mDAAmD;IACnD,KAAY,WAAW,CAAC,MAAM,SAAS,gBAAgB,IAAI,WAAW,CACpE,MAAM,CAAC,WAAW,CAAC,CAAC,OAAO,CAAC,CAC7B,CAAC,QAAQ,CAAC,CAAA;CACZ"}

package/types/standard-schema.ts

@@ -0,0 +1,76 @@
+/** The Standard Schema interface. */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly '~standard': StandardSchemaV1.Props<Input, Output>
+}
+
+export declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  export interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1
+    /** The vendor name of the schema library. */
+    readonly vendor: string
+    /** Validates unknown input values. */
+    readonly validate: (
+      value: unknown,
+      options?: StandardSchemaV1.Options | undefined
+    ) => Result<Output> | Promise<Result<Output>>
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined
+  }
+
+  /** The result interface of the validate function. */
+  export type Result<Output> = SuccessResult<Output> | FailureResult
+
+  /** The result interface if validation succeeds. */
+  export interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output
+    /** A falsy value for `issues` indicates success. */
+    readonly issues?: undefined
+  }
+
+  export interface Options {
+    /** Explicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined
+  }
+
+  /** The result interface if validation fails. */
+  export interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>
+  }
+
+  /** The issue interface of the failure output. */
+  export interface Issue {
+    /** The error message of the issue. */
+    readonly message: string
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined
+  }
+
+  /** The path segment interface of the issue. */
+  export interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey
+  }
+
+  /** The Standard Schema types interface. */
+  export interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input
+    /** The output type of the schema. */
+    readonly output: Output
+  }
+
+  /** Infers the input type of a Standard Schema. */
+  export type InferInput<Schema extends StandardSchemaV1> = NonNullable<
+    Schema['~standard']['types']
+  >['input']
+
+  /** Infers the output type of a Standard Schema. */
+  export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<
+    Schema['~standard']['types']
+  >['output']
+}

package/types/utils.d.ts

@@ -0,0 +1 @@
+type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never

package/cjs/impl/bulk.cjs

@@ -1,275 +0,0 @@
-"use strict";
-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 __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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var bulk_exports = {};
-__export(bulk_exports, {
-  bulkGet: () => bulkGet,
-  bulkGetDictionary: () => bulkGetDictionary,
-  bulkRemove: () => bulkRemove,
-  bulkSave: () => bulkSave,
-  bulkSaveTransaction: () => bulkSaveTransaction
-});
-module.exports = __toCommonJS(bulk_exports);
-var import_needle = __toESM(require("needle"), 1);
-var import_bulk = require("../schema/bulk.cjs");
-var import_retry = require("./retry.cjs");
-var import_crud = require("./crud.cjs");
-var import_errors = require("./errors.cjs");
-var import_transactionErrors = require("./transactionErrors.cjs");
-var import_logger = require("./logger.cjs");
-var import_crud2 = require("../schema/crud.cjs");
-var import_trackedEmitter = require("./trackedEmitter.cjs");
-const bulkSave = import_bulk.BulkSave.implement(async (config, docs) => {
-  const logger = (0, import_logger.createLogger)(config);
-  if (!docs) {
-    logger.warn("bulkSave called with no docs");
-    return { ok: false, error: "noDocs", reason: "no docs provided" };
-  }
-  if (!docs.length) {
-    logger.warn("bulkSave called with empty docs array");
-    return { ok: false, error: "noDocs", reason: "no docs provided" };
-  }
-  logger.info(`Starting bulk save of ${docs.length} documents`);
-  const url = `${config.couch}/_bulk_docs`;
-  const body = { docs };
-  const opts = {
-    json: true,
-    headers: {
-      "Content-Type": "application/json"
-    }
-  };
-  let resp;
-  try {
-    resp = await (0, import_needle.default)("post", url, body, opts);
-  } catch (err) {
-    logger.error("Network error during bulk save:", err);
-    import_errors.RetryableError.handleNetworkError(err);
-  }
-  if (!resp) {
-    logger.error("No response received from bulk save request");
-    throw new import_errors.RetryableError("no response", 503);
-  }
-  if (import_errors.RetryableError.isRetryableStatusCode(resp.statusCode)) {
-    logger.warn(`Retryable status code received: ${resp.statusCode}`);
-    throw new import_errors.RetryableError("retryable error during bulk save", resp.statusCode);
-  }
-  if (resp.statusCode !== 201) {
-    logger.error(`Unexpected status code: ${resp.statusCode}`);
-    throw new Error("could not save");
-  }
-  const results = resp?.body || [];
-  return results;
-});
-const bulkGet = import_bulk.BulkGet.implement(async (config, ids) => {
-  const logger = (0, import_logger.createLogger)(config);
-  const keys = ids;
-  logger.info(`Starting bulk get for ${keys.length} documents`);
-  const url = `${config.couch}/_all_docs?include_docs=true`;
-  const payload = { keys };
-  const opts = {
-    json: true,
-    headers: {
-      "Content-Type": "application/json"
-    }
-  };
-  let resp;
-  try {
-    resp = await (0, import_needle.default)("post", url, payload, opts);
-  } catch (err) {
-    logger.error("Network error during bulk get:", err);
-    import_errors.RetryableError.handleNetworkError(err);
-  }
-  if (!resp) {
-    logger.error("No response received from bulk get request");
-    throw new import_errors.RetryableError("no response", 503);
-  }
-  if (import_errors.RetryableError.isRetryableStatusCode(resp.statusCode)) {
-    logger.warn(`Retryable status code received: ${resp.statusCode}`);
-    throw new import_errors.RetryableError("retryable error during bulk get", resp.statusCode);
-  }
-  if (resp.statusCode !== 200) {
-    logger.error(`Unexpected status code: ${resp.statusCode}`);
-    throw new Error("could not fetch");
-  }
-  const body = resp.body;
-  return body;
-});
-const bulkRemove = import_bulk.BulkRemove.implement(async (config, ids) => {
-  const logger = (0, import_logger.createLogger)(config);
-  logger.info(`Starting bulk remove for ${ids.length} documents`);
-  const resp = await bulkGet(config, ids);
-  const toRemove = [];
-  resp.rows.forEach((row) => {
-    if (!row.doc) return;
-    try {
-      const d = import_crud2.CouchDoc.parse(row.doc);
-      d._deleted = true;
-      toRemove.push(d);
-    } catch (e) {
-      logger.warn(`Invalid document structure in bulk remove: ${row.id}`, e);
-    }
-  });
-  if (!toRemove.length) return [];
-  const result = await bulkSave(config, toRemove);
-  return result;
-});
-const bulkGetDictionary = import_bulk.BulkGetDictionary.implement(async (config, ids) => {
-  const resp = await bulkGet(config, ids);
-  const results = { found: {}, notFound: {} };
-  resp.rows.forEach(
-    /** @param { import('../schema/query.mjs').ViewRowSchema } row */
-    (row) => {
-      if (!row.key) return;
-      if (row.error) {
-        results.notFound[row.key] = row;
-        return;
-      }
-      try {
-        const doc = import_crud2.CouchDoc.parse(row.doc);
-        results.found[doc._id] = doc;
-      } catch (e) {
-        results.notFound[row.key] = row;
-      }
-    }
-  );
-  return results;
-});
-const bulkSaveTransaction = import_bulk.BulkSaveTransaction.implement(async (config, transactionId, docs) => {
-  const emitter = (0, import_trackedEmitter.setupEmitter)(config);
-  const logger = (0, import_logger.createLogger)(config);
-  const retryOptions = {
-    maxRetries: config.maxRetries ?? 10,
-    initialDelay: config.initialDelay ?? 1e3,
-    backoffFactor: config.backoffFactor ?? 2
-  };
-  const _put = config.bindWithRetry ? (0, import_retry.withRetry)(import_crud.put.bind(null, config), retryOptions) : import_crud.put.bind(null, config);
-  logger.info(`Starting bulk save transaction ${transactionId} for ${docs.length} documents`);
-  const txnDoc = {
-    _id: `txn:${transactionId}`,
-    _rev: null,
-    type: "transaction",
-    status: "pending",
-    changes: docs,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  let txnresp = await _put(txnDoc);
-  logger.debug("Transaction document created:", txnDoc, txnresp);
-  await emitter.emit("transaction-created", { txnresp, txnDoc });
-  if (txnresp.error) {
-    throw new import_transactionErrors.TransactionSetupError("Failed to create transaction document", {
-      error: txnresp.error,
-      response: txnresp.body
-    });
-  }
-  const existingDocs = await bulkGetDictionary(config, docs.map((d) => d._id));
-  logger.debug("Fetched current revisions of documents:", existingDocs);
-  await emitter.emit("transaction-revs-fetched", existingDocs);
-  const revErrors = [];
-  docs.forEach((d) => {
-    if (existingDocs.found[d._id] && existingDocs.found[d._id]._rev !== d._rev) revErrors.push(d._id);
-    if (existingDocs.notFound[d._id] && d._rev) revErrors.push(d._id);
-  });
-  if (revErrors.length > 0) {
-    throw new import_transactionErrors.TransactionVersionConflictError(revErrors);
-  }
-  logger.debug("Checked document revisions:", existingDocs);
-  await emitter.emit("transaction-revs-checked", existingDocs);
-  const providedDocsById = {};
-  docs.forEach((d) => {
-    if (!d._id) return;
-    providedDocsById[d._id] = d;
-  });
-  const newDocsToRollback = [];
-  const potentialExistingDocsToRollack = [];
-  const failedDocs = [];
-  try {
-    logger.info("Transaction started:", txnDoc);
-    await emitter.emit("transaction-started", txnDoc);
-    const results = await bulkSave(config, docs);
-    logger.info("Transaction updates applied:", results);
-    await emitter.emit("transaction-updates-applied", results);
-    results.forEach((r) => {
-      if (!r.id) return;
-      if (!r.error) {
-        if (existingDocs.notFound[r.id]) newDocsToRollback.push(r);
-        if (existingDocs.found[r.id]) potentialExistingDocsToRollack.push(r);
-      } else {
-        failedDocs.push(r);
-      }
-    });
-    if (failedDocs.length > 0) {
-      throw new import_transactionErrors.TransactionBulkOperationError(failedDocs);
-    }
-    txnDoc.status = "completed";
-    txnDoc._rev = txnresp.rev;
-    txnresp = await _put(txnDoc);
-    logger.info("Transaction completed:", txnDoc);
-    await emitter.emit("transaction-completed", { txnresp, txnDoc });
-    if (txnresp.statusCode !== 201) {
-      logger.error("Failed to update transaction status to completed");
-    }
-    return results;
-  } catch (error) {
-    logger.error("Transaction failed, attempting rollback:", error);
-    const toRollback = [];
-    potentialExistingDocsToRollack.forEach((row) => {
-      if (!row.id || !row.rev) return;
-      const doc = existingDocs.found[row.id];
-      doc._rev = row.rev;
-      toRollback.push(doc);
-    });
-    newDocsToRollback.forEach((d) => {
-      if (!d.id || !d.rev) return;
-      const before = JSON.parse(JSON.stringify(providedDocsById[d.id]));
-      before._rev = d.rev;
-      before._deleted = true;
-      toRollback.push(before);
-    });
-    const bulkRollbackResult = await bulkSave(config, toRollback);
-    let status = "rolled_back";
-    bulkRollbackResult.forEach((r) => {
-      if (r.error) status = "rollback_failed";
-    });
-    logger.warn("Transaction rolled back:", { bulkRollbackResult, status });
-    await emitter.emit("transaction-rolled-back", { bulkRollbackResult, status });
-    txnDoc.status = status;
-    txnDoc._rev = txnresp.rev;
-    txnresp = await _put(txnDoc);
-    logger.warn("Transaction rollback status updated:", txnDoc);
-    await emitter.emit("transaction-rolled-back-status", { txnresp, txnDoc });
-    if (txnresp.statusCode !== 201) {
-      logger.error("Failed to update transaction status to rolled_back");
-    }
-    throw new import_transactionErrors.TransactionRollbackError(
-      "Transaction failed and rollback was unsuccessful",
-      /** @type {Error} */
-      error,
-      bulkRollbackResult
-    );
-  }
-});

package/cjs/impl/changes.cjs

@@ -1,67 +0,0 @@
-"use strict";
-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 __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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var changes_exports = {};
-__export(changes_exports, {
-  changes: () => changes
-});
-module.exports = __toCommonJS(changes_exports);
-var import_needle = __toESM(require("needle"), 1);
-var import_events = require("events");
-var import_changes = require("../schema/changes.cjs");
-var import_changes_stream = __toESM(require("changes-stream"), 1);
-const changes = import_changes.Changes.implement(async (config, onChange, options = {}) => {
-  const emitter = new import_events.EventEmitter();
-  options.db = config.couch;
-  if (options.since && options.since === "now") {
-    const opts = {
-      json: true,
-      headers: {
-        "Content-Type": "application/json"
-      }
-    };
-    const resp = await (0, import_needle.default)("get", config.couch, opts);
-    options.since = resp.body.update_seq;
-  }
-  const changes2 = (0, import_changes_stream.default)(options);
-  changes2.on("readable", () => {
-    const change = changes2.read();
-    if (change.results && Array.isArray(change.results)) {
-      change.results.forEach((c) => emitter.emit("change", c));
-    } else emitter.emit("change", change);
-  });
-  emitter.on("change", onChange);
-  return {
-    on: (event, listener) => emitter.on(event, listener),
-    removeListener: (event, listener) => emitter.removeListener(event, listener),
-    stop: () => {
-      changes2.destroy();
-      emitter.removeAllListeners();
-    }
-  };
-});