hide-a-bed 4.0.0 → 4.0.1

package/index.mjs

@@ -5,7 +5,7 @@ import { patch } from './impl/patch.mjs'
 import { query } from './impl/query.mjs'
 import { queryStream } from './impl/stream.mjs'
 import { withRetry } from './impl/retry.mjs'
-import { BulkSave, BulkGet } from './schema/bulk.mjs'
+import { BulkSave, BulkGet, BulkRemove } from './schema/bulk.mjs'
 import { CouchConfig } from './schema/config.mjs'
 import { SimpleViewQuery, SimpleViewQueryResponse } from './schema/query.mjs'
 import { SimpleViewQueryStream, OnRow } from './schema/stream.mjs'
@@ -21,6 +21,7 @@ const schema = {
   OnRow,
   BulkSave,
   BulkGet,
+  BulkRemove,
   CouchGet,
   CouchPut,
   CouchDoc,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hide-a-bed",
-  "version": "4.0.0",
+  "version": "4.0.1",
   "description": "An abstraction over couchdb calls that includes easy mock/stubs with pouchdb",
   "module": "index.mjs",
   "main": "cjs/index.cjs",

package/impl/bulk.d.mts

@@ -1,7 +0,0 @@
-/** @type { import('../schema/bulk.mjs').BulkSaveSchema } */
-export const bulkSave: import("../schema/bulk.mjs").BulkSaveSchema;
-/** @type { import('../schema/bulk.mjs').BulkGetSchema } */
-export const bulkGet: import("../schema/bulk.mjs").BulkGetSchema;
-/** @type { import('../schema/bulk.mjs').BulkRemoveSchema } */
-export const bulkRemove: import("../schema/bulk.mjs").BulkRemoveSchema;
-//# sourceMappingURL=bulk.d.mts.map

package/impl/bulk.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bulk.d.mts","sourceRoot":"","sources":["bulk.mjs"],"names":[],"mappings":"AAaA,4DAA4D;AAC5D,uBADY,OAAO,oBAAoB,EAAE,cAAc,CAsCrD;AAEF,2DAA2D;AAC3D,sBADY,OAAO,oBAAoB,EAAE,aAAa,CA0CpD;AAEF,8DAA8D;AAC9D,yBADY,OAAO,oBAAoB,EAAE,gBAAgB,CAOvD"}

package/impl/crud.d.mts

@@ -1,5 +0,0 @@
-/** @type { import('../schema/crud.mjs').CouchGetSchema } */
-export const get: import("../schema/crud.mjs").CouchGetSchema;
-/** @type { import('../schema/crud.mjs').CouchPutSchema } */
-export const put: import("../schema/crud.mjs").CouchPutSchema;
-//# sourceMappingURL=crud.d.mts.map

package/impl/crud.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"crud.d.mts","sourceRoot":"","sources":["crud.mjs"],"names":[],"mappings":"AAaA,4DAA4D;AAC5D,kBADY,OAAO,oBAAoB,EAAE,cAAc,CAwCrD;AAEF,4DAA4D;AAC5D,kBADY,OAAO,oBAAoB,EAAE,cAAc,CAqCrD"}

package/impl/errors.d.mts

@@ -1,35 +0,0 @@
-/**
- * @typedef {Object} NetworkError
- * @property {string} code - The error code
- * @property {string} [message] - Optional error message
- */
-export class RetryableError extends Error {
-    /**
-     * @param {number|undefined} statusCode - The HTTP status code to check
-     * @returns {boolean} Whether the status code is retryable
-     */
-    static isRetryableStatusCode(statusCode: number | undefined): boolean;
-    /**
-     * @param {NetworkError | unknown} err - The network error to handle
-     * @throws {RetryableError} If the error is retryable
-     * @throws {Error} If the error is not retryable
-     */
-    static handleNetworkError(err: NetworkError | unknown): void;
-    /**
-     * @param {string} message - The error message
-     * @param {number|undefined} statusCode - The HTTP status code
-     */
-    constructor(message: string, statusCode: number | undefined);
-    statusCode: number | undefined;
-}
-export type NetworkError = {
-    /**
-     * - The error code
-     */
-    code: string;
-    /**
-     * - Optional error message
-     */
-    message?: string | undefined;
-};
-//# sourceMappingURL=errors.d.mts.map

package/impl/errors.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors.d.mts","sourceRoot":"","sources":["errors.mjs"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH;IAWE;;;OAGG;IACH,yCAHW,MAAM,GAAC,SAAS,GACd,OAAO,CAKnB;IAED;;;;OAIG;IACH,+BAJW,YAAY,GAAG,OAAO,QAsBhC;IA1CD;;;OAGG;IACH,qBAHW,MAAM,cACN,MAAM,GAAC,SAAS,EAM1B;IADC,+BAA4B;CAoC/B;;;;;UAhDa,MAAM"}

package/impl/logger.d.mts

@@ -1,32 +0,0 @@
-/**
- * @typedef {Object} Logger
- * @property {(...args: any[]) => void} error - Log error messages
- * @property {(...args: any[]) => void} warn - Log warning messages
- * @property {(...args: any[]) => void} info - Log info messages
- * @property {(...args: any[]) => void} debug - Log debug messages
- */
-/**
- * Creates a unified logger interface that works with both function and object-style loggers
- * @param {import('../schema/config.mjs').CouchConfigSchema} config
- * @returns {Logger} Normalized logger interface
- */
-export function createLogger(config: import("../schema/config.mjs").CouchConfigSchema): Logger;
-export type Logger = {
-    /**
-     * - Log error messages
-     */
-    error: (...args: any[]) => void;
-    /**
-     * - Log warning messages
-     */
-    warn: (...args: any[]) => void;
-    /**
-     * - Log info messages
-     */
-    info: (...args: any[]) => void;
-    /**
-     * - Log debug messages
-     */
-    debug: (...args: any[]) => void;
-};
-//# sourceMappingURL=logger.d.mts.map

package/impl/logger.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"logger.d.mts","sourceRoot":"","sources":["logger.mjs"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;GAIG;AACH,qCAHW,OAAO,sBAAsB,EAAE,iBAAiB,GAC9C,MAAM,CAsClB;;;;;WA/Ca,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI;;;;UACxB,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI;;;;UACxB,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI;;;;WACxB,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI"}

package/impl/patch.d.mts

@@ -1,4 +0,0 @@
-export function sleep(ms: any): Promise<any>;
-/** @type { import('../schema/patch.mjs').PatchSchema } */
-export const patch: import("../schema/patch.mjs").PatchSchema;
-//# sourceMappingURL=patch.d.mts.map

package/impl/patch.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"patch.d.mts","sourceRoot":"","sources":["patch.mjs"],"names":[],"mappings":"AAGO,6CAAmE;AAE1E,0DAA0D;AAC1D,oBADY,OAAO,qBAAqB,EAAE,WAAW,CAmCnD"}

package/impl/query.d.mts

@@ -1,170 +0,0 @@
-/**
- * @param {{ [key: string]: any }} options - The options object containing query parameters.
- * @param {string[]} params - The list of parameter names to include in the query string.
- */
-export function queryString(options: {
-    [key: string]: any;
-}, params: string[]): string;
-/** @type { z.infer<SimpleViewQuery> } query */
-export const query: z.infer<z.ZodFunction<z.ZodTuple<[z.ZodObject<{
-    throwOnGetNotFound: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    couch: z.ZodString;
-    bindWithRetry: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
-        error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
-        warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
-        info: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
-        debug: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
-    }, "strip", z.ZodTypeAny, {
-        error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
-        warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
-        info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
-        debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
-    }, {
-        error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
-        warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
-        info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
-        debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
-    }>, z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodAny], z.ZodUnknown>, z.ZodVoid>]>>;
-    _normalizedLogger: z.ZodOptional<z.ZodAny>;
-}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-    throwOnGetNotFound: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    couch: z.ZodString;
-    bindWithRetry: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
-        error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
-        warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
-        info: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
-        debug: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
-    }, "strip", z.ZodTypeAny, {
-        error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
-        warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
-        info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
-        debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
-    }, {
-        error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
-        warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
-        info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
-        debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
-    }>, z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodAny], z.ZodUnknown>, z.ZodVoid>]>>;
-    _normalizedLogger: z.ZodOptional<z.ZodAny>;
-}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-    throwOnGetNotFound: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    couch: z.ZodString;
-    bindWithRetry: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-    maxRetries: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    initialDelay: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    backoffFactor: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    logger: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
-        error: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
-        warn: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
-        info: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
-        debug: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodAny], z.ZodUnknown>, z.ZodVoid>>;
-    }, "strip", z.ZodTypeAny, {
-        error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
-        warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
-        info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
-        debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
-    }, {
-        error?: ((args_0: any, ...args: unknown[]) => void) | undefined;
-        warn?: ((args_0: any, ...args: unknown[]) => void) | undefined;
-        info?: ((args_0: any, ...args: unknown[]) => void) | undefined;
-        debug?: ((args_0: any, ...args: unknown[]) => void) | undefined;
-    }>, z.ZodFunction<z.ZodTuple<[z.ZodString, z.ZodAny], z.ZodUnknown>, z.ZodVoid>]>>;
-    _normalizedLogger: z.ZodOptional<z.ZodAny>;
-}, z.ZodTypeAny, "passthrough">>, z.ZodString, z.ZodOptional<z.ZodObject<{
-    startkey: z.ZodOptional<z.ZodAny>;
-    endkey: z.ZodOptional<z.ZodAny>;
-    descending: z.ZodOptional<z.ZodBoolean>;
-    skip: z.ZodOptional<z.ZodNumber>;
-    limit: z.ZodOptional<z.ZodNumber>;
-    key: z.ZodOptional<z.ZodAny>;
-    include_docs: z.ZodOptional<z.ZodBoolean>;
-    reduce: z.ZodOptional<z.ZodBoolean>;
-    group: z.ZodOptional<z.ZodBoolean>;
-    group_level: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    startkey?: any;
-    endkey?: any;
-    descending?: boolean | undefined;
-    skip?: number | undefined;
-    limit?: number | undefined;
-    key?: any;
-    include_docs?: boolean | undefined;
-    reduce?: boolean | undefined;
-    group?: boolean | undefined;
-    group_level?: number | undefined;
-}, {
-    startkey?: any;
-    endkey?: any;
-    descending?: boolean | undefined;
-    skip?: number | undefined;
-    limit?: number | undefined;
-    key?: any;
-    include_docs?: boolean | undefined;
-    reduce?: boolean | undefined;
-    group?: boolean | undefined;
-    group_level?: number | undefined;
-}>>], z.ZodUnknown>, z.ZodPromise<z.ZodObject<{
-    error: z.ZodOptional<z.ZodString>;
-    rows: z.ZodArray<z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        key: z.ZodNullable<z.ZodAny>;
-        value: z.ZodNullable<z.ZodAny>;
-        doc: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
-    }, "strip", z.ZodTypeAny, {
-        id?: string | undefined;
-        key?: any;
-        value?: any;
-        doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
-    }, {
-        id?: string | undefined;
-        key?: any;
-        value?: any;
-        doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
-    }>, "many">;
-}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
-    error: z.ZodOptional<z.ZodString>;
-    rows: z.ZodArray<z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        key: z.ZodNullable<z.ZodAny>;
-        value: z.ZodNullable<z.ZodAny>;
-        doc: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
-    }, "strip", z.ZodTypeAny, {
-        id?: string | undefined;
-        key?: any;
-        value?: any;
-        doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
-    }, {
-        id?: string | undefined;
-        key?: any;
-        value?: any;
-        doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
-    }>, "many">;
-}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
-    error: z.ZodOptional<z.ZodString>;
-    rows: z.ZodArray<z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        key: z.ZodNullable<z.ZodAny>;
-        value: z.ZodNullable<z.ZodAny>;
-        doc: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
-    }, "strip", z.ZodTypeAny, {
-        id?: string | undefined;
-        key?: any;
-        value?: any;
-        doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
-    }, {
-        id?: string | undefined;
-        key?: any;
-        value?: any;
-        doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
-    }>, "many">;
-}, z.ZodTypeAny, "passthrough">>>>>;
-import { z } from 'zod';
-//# sourceMappingURL=query.d.mts.map

package/impl/query.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"query.d.mts","sourceRoot":"","sources":["query.mjs"],"names":[],"mappings":"AAuCA;;;GAGG;AACH,qCAHW;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,UACtB,MAAM,EAAE,UAoBlB;AAnDD,+CAA+C;AAC/C,oBADY,CAAC,CAAC,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAAiB,CA2BlC;kBAnCgB,KAAK"}

package/impl/retry.d.mts

@@ -1,2 +0,0 @@
-export function withRetry(fn: any, options?: {}): (...args: any[]) => Promise<any>;
-//# sourceMappingURL=retry.d.mts.map

package/impl/retry.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"retry.d.mts","sourceRoot":"","sources":["retry.mjs"],"names":[],"mappings":"AAGA,mFAmCC"}

package/impl/stream.d.mts

@@ -1,3 +0,0 @@
-/** @type { import('../schema/stream.mjs').SimpleViewQueryStreamSchema } */
-export const queryStream: import("../schema/stream.mjs").SimpleViewQueryStreamSchema;
-//# sourceMappingURL=stream.d.mts.map

package/impl/stream.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stream.d.mts","sourceRoot":"","sources":["stream.mjs"],"names":[],"mappings":"AAOA,2EAA2E;AAC3E,0BADY,OAAO,sBAAsB,EAAE,2BAA2B,CAoDpE"}

package/index.d.mts

@@ -1,39 +0,0 @@
-import { get } from './impl/crud.mjs';
-import { put } from './impl/crud.mjs';
-import { patch } from './impl/patch.mjs';
-import { bulkGet } from './impl/bulk.mjs';
-import { bulkSave } from './impl/bulk.mjs';
-import { bulkRemove } from './impl/bulk.mjs';
-import { query } from './impl/query.mjs';
-import { queryStream } from './impl/stream.mjs';
-export namespace schema {
-    export { CouchConfig };
-    export { SimpleViewQuery };
-    export { SimpleViewQueryResponse };
-    export { SimpleViewQueryStream };
-    export { OnRow };
-    export { BulkSave };
-    export { BulkGet };
-    export { CouchGet };
-    export { CouchPut };
-    export { CouchDoc };
-    export { CouchDocResponse };
-    export { Patch };
-}
-/** @type { import('./schema/bind.mjs').BindSchema } */
-export const bindConfig: import("./schema/bind.mjs").BindSchema;
-import { withRetry } from './impl/retry.mjs';
-import { CouchConfig } from './schema/config.mjs';
-import { SimpleViewQuery } from './schema/query.mjs';
-import { SimpleViewQueryResponse } from './schema/query.mjs';
-import { SimpleViewQueryStream } from './schema/stream.mjs';
-import { OnRow } from './schema/stream.mjs';
-import { BulkSave } from './schema/bulk.mjs';
-import { BulkGet } from './schema/bulk.mjs';
-import { CouchGet } from './schema/crud.mjs';
-import { CouchPut } from './schema/crud.mjs';
-import { CouchDoc } from './schema/crud.mjs';
-import { CouchDocResponse } from './schema/crud.mjs';
-import { Patch } from './schema/patch.mjs';
-export { get, put, patch, bulkGet, bulkSave, bulkRemove, query, queryStream, withRetry };
-//# sourceMappingURL=index.d.mts.map

package/index.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["index.mjs"],"names":[],"mappings":"oBAEyB,iBAAiB;oBAAjB,iBAAiB;sBACpB,kBAAkB;wBAFM,iBAAiB;yBAAjB,iBAAiB;2BAAjB,iBAAiB;sBAGzC,kBAAkB;4BACZ,mBAAmB;;;;;;;;;;;;;;;AAyB/C,uDAAuD;AACvD,yBADY,OAAO,mBAAmB,EAAE,UAAU,CAsBhD;0BA9CwB,kBAAkB;4BAEhB,qBAAqB;gCACQ,oBAAoB;wCAApB,oBAAoB;sCAChC,qBAAqB;sBAArB,qBAAqB;yBAHhC,mBAAmB;wBAAnB,mBAAmB;yBAKU,mBAAmB;yBAAnB,mBAAmB;yBAAnB,mBAAmB;iCAAnB,mBAAmB;sBAD5D,oBAAoB"}