hide-a-bed 3.0.0 → 3.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (28) hide show
  1. package/cjs/index.cjs +1 -1
  2. package/cjs/schema/patch.cjs +2 -2
  3. package/impl/bulk.d.mts +7 -0
  4. package/impl/bulk.d.mts.map +1 -0
  5. package/impl/crud.d.mts +10 -0
  6. package/impl/crud.d.mts.map +1 -0
  7. package/impl/patch.d.mts +2 -0
  8. package/impl/patch.d.mts.map +1 -0
  9. package/impl/patch.mjs +2 -2
  10. package/impl/query.d.mts +104 -0
  11. package/impl/query.d.mts.map +1 -0
  12. package/impl/stream.d.mts +2 -0
  13. package/impl/stream.d.mts.map +1 -0
  14. package/index.d.mts +34 -0
  15. package/index.d.mts.map +1 -0
  16. package/index.mjs +2 -2
  17. package/package.json +1 -1
  18. package/schema/bulk.d.mts +100 -0
  19. package/schema/bulk.d.mts.map +1 -0
  20. package/schema/config.d.mts +9 -0
  21. package/schema/config.d.mts.map +1 -0
  22. package/schema/crud.d.mts +83 -0
  23. package/schema/crud.d.mts.map +1 -0
  24. package/schema/patch.d.mts +47 -0
  25. package/schema/patch.d.mts.map +1 -0
  26. package/schema/patch.mjs +1 -1
  27. package/schema/query.d.mts +151 -0
  28. package/schema/query.d.mts.map +1 -0
package/cjs/index.cjs CHANGED
@@ -50,5 +50,5 @@ const schema = {
50
50
  CouchDoc: import_crud2.CouchDoc,
51
51
  CouchDocResponse: import_crud2.CouchDocResponse,
52
52
  PatchConfig: import_patch2.PatchConfig,
53
- PatchDoc: import_patch2.PatchDoc
53
+ Patch: import_patch2.Patch
54
54
  };
package/cjs/schema/patch.cjs CHANGED
@@ -18,7 +18,7 @@ var __copyProps = (to, from, except, desc) => {
18
18
  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
19
19
  var patch_exports = {};
20
20
  __export(patch_exports, {
21
- CouchPatch: () => CouchPatch,
21
+ Patch: () => Patch,
22
22
  PatchConfig: () => PatchConfig,
23
23
  PatchProperties: () => PatchProperties
24
24
  });
@@ -31,7 +31,7 @@ const PatchConfig = import_config.CouchConfig.extend({
31
31
  delay: import_zod.z.number().min(0).optional()
32
32
  });
33
33
  const PatchProperties = import_zod.z.record(import_zod.z.string(), import_zod.z.any());
34
- const CouchPatch = import_zod.z.function().args(
34
+ const Patch = import_zod.z.function().args(
35
35
  PatchConfig,
36
36
  import_zod.z.string().describe("the couch doc id"),
37
37
  PatchProperties
package/impl/bulk.d.mts ADDED
@@ -0,0 +1,7 @@
1
+ /** @type { import('../schema/bulk.mjs').BulkSaveSchema } */
2
+ export const bulkSave: import("../schema/bulk.mjs").BulkSaveSchema;
3
+ /** @type { import('../schema/bulk.mjs').BulkGetSchema } */
4
+ export const bulkGet: import("../schema/bulk.mjs").BulkGetSchema;
5
+ /** @type { import('../schema/bulk.mjs').BulkRemoveSchema } */
6
+ export const bulkRemove: import("../schema/bulk.mjs").BulkRemoveSchema;
7
+ //# sourceMappingURL=bulk.d.mts.map
package/impl/bulk.d.mts.map ADDED
@@ -0,0 +1 @@
1
+ {"version":3,"file":"bulk.d.mts","sourceRoot":"","sources":["bulk.mjs"],"names":[],"mappings":"AAWA,4DAA4D;AAC5D,uBADY,OAAO,oBAAoB,EAAE,cAAc,CAWrD;AAEF,2DAA2D;AAC3D,sBADY,OAAO,oBAAoB,EAAE,aAAa,CAqBpD;AAEF,8DAA8D;AAC9D,yBADY,OAAO,oBAAoB,EAAE,gBAAgB,CAKvD"}
package/impl/crud.d.mts ADDED
@@ -0,0 +1,10 @@
1
+ export const get: (args_0: import("zod").objectInputType<{
2
+ couch: import("zod").ZodString;
3
+ }, import("zod").ZodTypeAny, "passthrough">, args_1: string, ...args: unknown[]) => Promise<any>;
4
+ export const put: (args_0: import("zod").objectInputType<{
5
+ couch: import("zod").ZodString;
6
+ }, import("zod").ZodTypeAny, "passthrough">, args_1: import("zod").objectInputType<{
7
+ _id: import("zod").ZodString;
8
+ _rev: import("zod").ZodOptional<import("zod").ZodString>;
9
+ }, import("zod").ZodTypeAny, "passthrough">, ...args: unknown[]) => Promise<any>;
10
+ //# sourceMappingURL=crud.d.mts.map
package/impl/crud.d.mts.map ADDED
@@ -0,0 +1 @@
1
+ {"version":3,"file":"crud.d.mts","sourceRoot":"","sources":["crud.mjs"],"names":[],"mappings":"AAWA;;iGAOE;AAEF;;;;;iFAWE"}
package/impl/patch.d.mts ADDED
@@ -0,0 +1,2 @@
1
+ export const patch: any;
2
+ //# sourceMappingURL=patch.d.mts.map
package/impl/patch.d.mts.map ADDED
@@ -0,0 +1 @@
1
+ {"version":3,"file":"patch.d.mts","sourceRoot":"","sources":["patch.mjs"],"names":[],"mappings":"AAKA,wBA8BE"}
package/impl/patch.mjs CHANGED
@@ -1,9 +1,9 @@
1
1
  import { get, put } from './crud.mjs'
2
- import { CouchPatch } from '../schema/patch.mjs'
2
+ import { Patch } from '../schema/patch.mjs'
3
3
 
4
4
  const sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
5
5
 
6
- export const patch = CouchPatch.implement(async (config, id, properties) => {
6
+ export const patch = Patch.implement(async (config, id, properties) => {
7
7
  const maxRetries = config.retries || 5
8
8
  const delay = config.delay || 1000
9
9
  let attempts = 0
package/impl/query.d.mts ADDED
@@ -0,0 +1,104 @@
1
+ /**
2
+ * @param {{ [key: string]: any }} options - The options object containing query parameters.
3
+ * @param {string[]} params - The list of parameter names to include in the query string.
4
+ */
5
+ export function queryString(options: {
6
+ [key: string]: any;
7
+ }, params: string[]): string;
8
+ /** @type { z.infer<SimpleViewQuery> } query */
9
+ export const query: z.infer<z.ZodFunction<z.ZodTuple<[z.ZodObject<{
10
+ couch: z.ZodString;
11
+ }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
12
+ couch: z.ZodString;
13
+ }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
14
+ couch: z.ZodString;
15
+ }, z.ZodTypeAny, "passthrough">>, z.ZodString, z.ZodOptional<z.ZodObject<{
16
+ startkey: z.ZodOptional<z.ZodAny>;
17
+ endkey: z.ZodOptional<z.ZodAny>;
18
+ descending: z.ZodOptional<z.ZodBoolean>;
19
+ skip: z.ZodOptional<z.ZodNumber>;
20
+ limit: z.ZodOptional<z.ZodNumber>;
21
+ key: z.ZodOptional<z.ZodAny>;
22
+ include_docs: z.ZodOptional<z.ZodBoolean>;
23
+ reduce: z.ZodOptional<z.ZodBoolean>;
24
+ group: z.ZodOptional<z.ZodBoolean>;
25
+ group_level: z.ZodOptional<z.ZodNumber>;
26
+ }, "strip", z.ZodTypeAny, {
27
+ startkey?: any;
28
+ endkey?: any;
29
+ descending?: boolean | undefined;
30
+ skip?: number | undefined;
31
+ limit?: number | undefined;
32
+ key?: any;
33
+ include_docs?: boolean | undefined;
34
+ reduce?: boolean | undefined;
35
+ group?: boolean | undefined;
36
+ group_level?: number | undefined;
37
+ }, {
38
+ startkey?: any;
39
+ endkey?: any;
40
+ descending?: boolean | undefined;
41
+ skip?: number | undefined;
42
+ limit?: number | undefined;
43
+ key?: any;
44
+ include_docs?: boolean | undefined;
45
+ reduce?: boolean | undefined;
46
+ group?: boolean | undefined;
47
+ group_level?: number | undefined;
48
+ }>>], z.ZodUnknown>, z.ZodPromise<z.ZodObject<{
49
+ error: z.ZodOptional<z.ZodString>;
50
+ rows: z.ZodArray<z.ZodObject<{
51
+ id: z.ZodOptional<z.ZodString>;
52
+ key: z.ZodNullable<z.ZodAny>;
53
+ value: z.ZodNullable<z.ZodAny>;
54
+ doc: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
55
+ }, "strip", z.ZodTypeAny, {
56
+ id?: string | undefined;
57
+ key?: any;
58
+ value?: any;
59
+ doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
60
+ }, {
61
+ id?: string | undefined;
62
+ key?: any;
63
+ value?: any;
64
+ doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
65
+ }>, "many">;
66
+ }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
67
+ error: z.ZodOptional<z.ZodString>;
68
+ rows: z.ZodArray<z.ZodObject<{
69
+ id: z.ZodOptional<z.ZodString>;
70
+ key: z.ZodNullable<z.ZodAny>;
71
+ value: z.ZodNullable<z.ZodAny>;
72
+ doc: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
73
+ }, "strip", z.ZodTypeAny, {
74
+ id?: string | undefined;
75
+ key?: any;
76
+ value?: any;
77
+ doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
78
+ }, {
79
+ id?: string | undefined;
80
+ key?: any;
81
+ value?: any;
82
+ doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
83
+ }>, "many">;
84
+ }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
85
+ error: z.ZodOptional<z.ZodString>;
86
+ rows: z.ZodArray<z.ZodObject<{
87
+ id: z.ZodOptional<z.ZodString>;
88
+ key: z.ZodNullable<z.ZodAny>;
89
+ value: z.ZodNullable<z.ZodAny>;
90
+ doc: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
91
+ }, "strip", z.ZodTypeAny, {
92
+ id?: string | undefined;
93
+ key?: any;
94
+ value?: any;
95
+ doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
96
+ }, {
97
+ id?: string | undefined;
98
+ key?: any;
99
+ value?: any;
100
+ doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
101
+ }>, "many">;
102
+ }, z.ZodTypeAny, "passthrough">>>>>;
103
+ import { z } from 'zod';
104
+ //# sourceMappingURL=query.d.mts.map
package/impl/query.d.mts.map ADDED
@@ -0,0 +1 @@
1
+ {"version":3,"file":"query.d.mts","sourceRoot":"","sources":["query.mjs"],"names":[],"mappings":"AA6BA;;;GAGG;AACH,qCAHW;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,UACtB,MAAM,EAAE,UAoBlB;AA1CD,+CAA+C;AAC/C,oBADY,CAAC,CAAC,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAAiB,CAkBlC;kBAzBgB,KAAK"}
package/impl/stream.d.mts ADDED
@@ -0,0 +1,2 @@
1
+ export function queryStream(config: any, view: any, options: any): Promise<any>;
2
+ //# sourceMappingURL=stream.d.mts.map
package/impl/stream.d.mts.map ADDED
@@ -0,0 +1 @@
1
+ {"version":3,"file":"stream.d.mts","sourceRoot":"","sources":["stream.mjs"],"names":[],"mappings":"AAYO,oCAJI,GAAG,QACH,GAAG,WACH,GAAG,gBAkBZ"}
package/index.d.mts ADDED
@@ -0,0 +1,34 @@
1
+ import { get } from './impl/crud.mjs';
2
+ import { put } from './impl/crud.mjs';
3
+ import { patch } from './impl/patch.mjs';
4
+ import { bulkGet } from './impl/bulk.mjs';
5
+ import { bulkSave } from './impl/bulk.mjs';
6
+ import { bulkRemove } from './impl/bulk.mjs';
7
+ import { query } from './impl/query.mjs';
8
+ import { queryStream } from './impl/stream.mjs';
9
+ export namespace schema {
10
+ export { CouchConfig };
11
+ export { SimpleViewQuery };
12
+ export { SimpleViewQueryResponse };
13
+ export { BulkSave };
14
+ export { BulkGet };
15
+ export { CouchGet };
16
+ export { CouchPut };
17
+ export { CouchDoc };
18
+ export { CouchDocResponse };
19
+ export { PatchConfig };
20
+ export { Patch };
21
+ }
22
+ import { CouchConfig } from './schema/config.mjs';
23
+ import { SimpleViewQuery } from './schema/query.mjs';
24
+ import { SimpleViewQueryResponse } from './schema/query.mjs';
25
+ import { BulkSave } from './schema/bulk.mjs';
26
+ import { BulkGet } from './schema/bulk.mjs';
27
+ import { CouchGet } from './schema/crud.mjs';
28
+ import { CouchPut } from './schema/crud.mjs';
29
+ import { CouchDoc } from './schema/crud.mjs';
30
+ import { CouchDocResponse } from './schema/crud.mjs';
31
+ import { PatchConfig } from './schema/patch.mjs';
32
+ import { Patch } from './schema/patch.mjs';
33
+ export { get, put, patch, bulkGet, bulkSave, bulkRemove, query, queryStream };
34
+ //# sourceMappingURL=index.d.mts.map
package/index.d.mts.map ADDED
@@ -0,0 +1 @@
1
+ {"version":3,"file":"index.d.mts","sourceRoot":"","sources":["index.mjs"],"names":[],"mappings":"oBACyB,iBAAiB;oBAAjB,iBAAiB;sBACpB,kBAAkB;wBAFM,iBAAiB;yBAAjB,iBAAiB;2BAAjB,iBAAiB;sBAGzC,kBAAkB;4BACZ,mBAAmB;;;;;;;;;;;;;;4BAEnB,qBAAqB;gCACQ,oBAAoB;wCAApB,oBAAoB;yBAF3C,mBAAmB;wBAAnB,mBAAmB;yBAIU,mBAAmB;yBAAnB,mBAAmB;yBAAnB,mBAAmB;iCAAnB,mBAAmB;4BAD/C,oBAAoB;sBAApB,oBAAoB"}
package/index.mjs CHANGED
@@ -6,7 +6,7 @@ import { queryStream } from './impl/stream.mjs'
6
6
  import { BulkSave, BulkGet } from './schema/bulk.mjs'
7
7
  import { CouchConfig } from './schema/config.mjs'
8
8
  import { SimpleViewQuery, SimpleViewQueryResponse } from './schema/query.mjs'
9
- import { PatchConfig, PatchDoc } from './schema/patch.mjs'
9
+ import { PatchConfig, Patch } from './schema/patch.mjs'
10
10
  import { CouchDoc, CouchDocResponse, CouchPut, CouchGet } from './schema/crud.mjs'
11
11
 
12
12
  const schema = {
@@ -20,7 +20,7 @@ const schema = {
20
20
  CouchDoc,
21
21
  CouchDocResponse,
22
22
  PatchConfig,
23
- PatchDoc
23
+ Patch
24
24
  }
25
25
 
26
26
  export { get, put, patch, bulkGet, bulkSave, bulkRemove, query, queryStream, schema }
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "hide-a-bed",
3
- "version": "3.0.0",
3
+ "version": "3.0.1",
4
4
  "description": "An abstraction over couchdb calls that includes easy mock/stubs with pouchdb",
5
5
  "module": "index.mjs",
6
6
  "main": "cjs/index.cjs",
package/schema/bulk.d.mts ADDED
@@ -0,0 +1,100 @@
1
+ export const BulkSaveResponseSchema: z.ZodArray<z.ZodObject<{
2
+ ok: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
3
+ id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
4
+ rev: z.ZodOptional<z.ZodNullable<z.ZodString>>;
5
+ error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
6
+ reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
7
+ }, "strip", z.ZodTypeAny, {
8
+ ok?: boolean | null | undefined;
9
+ id?: string | null | undefined;
10
+ rev?: string | null | undefined;
11
+ error?: string | null | undefined;
12
+ reason?: string | null | undefined;
13
+ }, {
14
+ ok?: boolean | null | undefined;
15
+ id?: string | null | undefined;
16
+ rev?: string | null | undefined;
17
+ error?: string | null | undefined;
18
+ reason?: string | null | undefined;
19
+ }>, "many">;
20
+ /** @typedef { z.infer<typeof BulkSaveResponseSchema> } Response */
21
+ export const BulkSave: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
22
+ couch: z.ZodString;
23
+ }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
24
+ couch: z.ZodString;
25
+ }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
26
+ couch: z.ZodString;
27
+ }, z.ZodTypeAny, "passthrough">>, z.ZodArray<z.ZodObject<{
28
+ _id: z.ZodString;
29
+ }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
30
+ _id: z.ZodString;
31
+ }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
32
+ _id: z.ZodString;
33
+ }, z.ZodTypeAny, "passthrough">>, "many">], z.ZodUnknown>, z.ZodPromise<z.ZodArray<z.ZodObject<{
34
+ ok: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
35
+ id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
36
+ rev: z.ZodOptional<z.ZodNullable<z.ZodString>>;
37
+ error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
38
+ reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
39
+ }, "strip", z.ZodTypeAny, {
40
+ ok?: boolean | null | undefined;
41
+ id?: string | null | undefined;
42
+ rev?: string | null | undefined;
43
+ error?: string | null | undefined;
44
+ reason?: string | null | undefined;
45
+ }, {
46
+ ok?: boolean | null | undefined;
47
+ id?: string | null | undefined;
48
+ rev?: string | null | undefined;
49
+ error?: string | null | undefined;
50
+ reason?: string | null | undefined;
51
+ }>, "many">>>;
52
+ /** @typedef { z.infer<typeof BulkSave> } BulkSaveSchema */
53
+ export const BulkGet: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
54
+ couch: z.ZodString;
55
+ }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
56
+ couch: z.ZodString;
57
+ }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
58
+ couch: z.ZodString;
59
+ }, z.ZodTypeAny, "passthrough">>, z.ZodArray<z.ZodString, "many">], z.ZodUnknown>, z.ZodPromise<z.ZodArray<z.ZodObject<{
60
+ _id: z.ZodString;
61
+ _rev: z.ZodOptional<z.ZodString>;
62
+ }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
63
+ _id: z.ZodString;
64
+ _rev: z.ZodOptional<z.ZodString>;
65
+ }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
66
+ _id: z.ZodString;
67
+ _rev: z.ZodOptional<z.ZodString>;
68
+ }, z.ZodTypeAny, "passthrough">>, "many">>>;
69
+ /** @typedef { z.infer<typeof BulkGet> } BulkGetSchema */
70
+ export const BulkRemove: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
71
+ couch: z.ZodString;
72
+ }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
73
+ couch: z.ZodString;
74
+ }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
75
+ couch: z.ZodString;
76
+ }, z.ZodTypeAny, "passthrough">>, z.ZodArray<z.ZodString, "many">], z.ZodUnknown>, z.ZodPromise<z.ZodArray<z.ZodObject<{
77
+ ok: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
78
+ id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
79
+ rev: z.ZodOptional<z.ZodNullable<z.ZodString>>;
80
+ error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
81
+ reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
82
+ }, "strip", z.ZodTypeAny, {
83
+ ok?: boolean | null | undefined;
84
+ id?: string | null | undefined;
85
+ rev?: string | null | undefined;
86
+ error?: string | null | undefined;
87
+ reason?: string | null | undefined;
88
+ }, {
89
+ ok?: boolean | null | undefined;
90
+ id?: string | null | undefined;
91
+ rev?: string | null | undefined;
92
+ error?: string | null | undefined;
93
+ reason?: string | null | undefined;
94
+ }>, "many">>>;
95
+ export type Response = z.infer<typeof BulkSaveResponseSchema>;
96
+ export type BulkSaveSchema = z.infer<typeof BulkSave>;
97
+ export type BulkGetSchema = z.infer<typeof BulkGet>;
98
+ export type BulkRemoveSchema = z.infer<typeof BulkRemove>;
99
+ import { z } from 'zod';
100
+ //# sourceMappingURL=bulk.d.mts.map
package/schema/bulk.d.mts.map ADDED
@@ -0,0 +1 @@
1
+ {"version":3,"file":"bulk.d.mts","sourceRoot":"","sources":["bulk.mjs"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;YAMG;AACH,mEAAmE;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAK4C;AAC5C,2DAA2D;AAE3D;;;;;;;;;;;;;;;4CAGuC;AACvC,yDAAyD;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;cAG4C;uBAnB7B,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC;6BAQtC,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC;4BAMxB,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC;+BAMvB,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC;kBA/BvB,KAAK"}
package/schema/config.d.mts ADDED
@@ -0,0 +1,9 @@
1
+ export const CouchConfig: z.ZodObject<{
2
+ couch: z.ZodString;
3
+ }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
4
+ couch: z.ZodString;
5
+ }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
6
+ couch: z.ZodString;
7
+ }, z.ZodTypeAny, "passthrough">>;
8
+ import { z } from 'zod';
9
+ //# sourceMappingURL=config.d.mts.map
package/schema/config.d.mts.map ADDED
@@ -0,0 +1 @@
1
+ {"version":3,"file":"config.d.mts","sourceRoot":"","sources":["config.mjs"],"names":[],"mappings":"AACA;;;;;;iCAEkD;kBAHhC,KAAK"}
package/schema/crud.d.mts ADDED
@@ -0,0 +1,83 @@
1
+ export const CouchDoc: z.ZodObject<{
2
+ _id: z.ZodString;
3
+ _rev: z.ZodOptional<z.ZodString>;
4
+ }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
5
+ _id: z.ZodString;
6
+ _rev: z.ZodOptional<z.ZodString>;
7
+ }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
8
+ _id: z.ZodString;
9
+ _rev: z.ZodOptional<z.ZodString>;
10
+ }, z.ZodTypeAny, "passthrough">>;
11
+ /** @typedef { z.infer<typeof CouchDoc> } CouchDocSchema */
12
+ export const CouchDocResponse: z.ZodObject<{
13
+ ok: z.ZodOptional<z.ZodBoolean>;
14
+ error: z.ZodOptional<z.ZodString>;
15
+ statusCode: z.ZodNumber;
16
+ id: z.ZodOptional<z.ZodString>;
17
+ rev: z.ZodOptional<z.ZodString>;
18
+ }, "strip", z.ZodTypeAny, {
19
+ statusCode: number;
20
+ ok?: boolean | undefined;
21
+ error?: string | undefined;
22
+ id?: string | undefined;
23
+ rev?: string | undefined;
24
+ }, {
25
+ statusCode: number;
26
+ ok?: boolean | undefined;
27
+ error?: string | undefined;
28
+ id?: string | undefined;
29
+ rev?: string | undefined;
30
+ }>;
31
+ export const CouchPut: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
32
+ couch: z.ZodString;
33
+ }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
34
+ couch: z.ZodString;
35
+ }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
36
+ couch: z.ZodString;
37
+ }, z.ZodTypeAny, "passthrough">>, z.ZodObject<{
38
+ _id: z.ZodString;
39
+ _rev: z.ZodOptional<z.ZodString>;
40
+ }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
41
+ _id: z.ZodString;
42
+ _rev: z.ZodOptional<z.ZodString>;
43
+ }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
44
+ _id: z.ZodString;
45
+ _rev: z.ZodOptional<z.ZodString>;
46
+ }, z.ZodTypeAny, "passthrough">>], z.ZodUnknown>, z.ZodPromise<z.ZodObject<{
47
+ ok: z.ZodOptional<z.ZodBoolean>;
48
+ error: z.ZodOptional<z.ZodString>;
49
+ statusCode: z.ZodNumber;
50
+ id: z.ZodOptional<z.ZodString>;
51
+ rev: z.ZodOptional<z.ZodString>;
52
+ }, "strip", z.ZodTypeAny, {
53
+ statusCode: number;
54
+ ok?: boolean | undefined;
55
+ error?: string | undefined;
56
+ id?: string | undefined;
57
+ rev?: string | undefined;
58
+ }, {
59
+ statusCode: number;
60
+ ok?: boolean | undefined;
61
+ error?: string | undefined;
62
+ id?: string | undefined;
63
+ rev?: string | undefined;
64
+ }>>>;
65
+ export const CouchGet: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
66
+ couch: z.ZodString;
67
+ }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
68
+ couch: z.ZodString;
69
+ }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
70
+ couch: z.ZodString;
71
+ }, z.ZodTypeAny, "passthrough">>, z.ZodString], z.ZodUnknown>, z.ZodPromise<z.ZodNullable<z.ZodObject<{
72
+ _id: z.ZodString;
73
+ _rev: z.ZodOptional<z.ZodString>;
74
+ }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
75
+ _id: z.ZodString;
76
+ _rev: z.ZodOptional<z.ZodString>;
77
+ }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
78
+ _id: z.ZodString;
79
+ _rev: z.ZodOptional<z.ZodString>;
80
+ }, z.ZodTypeAny, "passthrough">>>>>;
81
+ export type CouchDocSchema = z.infer<typeof CouchDoc>;
82
+ import { z } from 'zod';
83
+ //# sourceMappingURL=crud.d.mts.map
package/schema/crud.d.mts.map ADDED
@@ -0,0 +1 @@
1
+ {"version":3,"file":"crud.d.mts","sourceRoot":"","sources":["crud.mjs"],"names":[],"mappings":"AAGA;;;;;;;;;iCAGgB;AAChB,2DAA2D;AAE3D;;;;;;;;;;;;;;;;;;GAME;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAGsC;AAEtC;;;;;;;;;;;;;;;oCAGyC;6BAlB1B,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC;kBAPrB,KAAK"}
package/schema/patch.d.mts ADDED
@@ -0,0 +1,47 @@
1
+ export const PatchConfig: z.ZodObject<{
2
+ couch: z.ZodString;
3
+ retries: z.ZodOptional<z.ZodNumber>;
4
+ delay: z.ZodOptional<z.ZodNumber>;
5
+ }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
6
+ couch: z.ZodString;
7
+ retries: z.ZodOptional<z.ZodNumber>;
8
+ delay: z.ZodOptional<z.ZodNumber>;
9
+ }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
10
+ couch: z.ZodString;
11
+ retries: z.ZodOptional<z.ZodNumber>;
12
+ delay: z.ZodOptional<z.ZodNumber>;
13
+ }, z.ZodTypeAny, "passthrough">>;
14
+ export const PatchProperties: z.ZodRecord<z.ZodString, z.ZodAny>;
15
+ export const Patch: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
16
+ couch: z.ZodString;
17
+ retries: z.ZodOptional<z.ZodNumber>;
18
+ delay: z.ZodOptional<z.ZodNumber>;
19
+ }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
20
+ couch: z.ZodString;
21
+ retries: z.ZodOptional<z.ZodNumber>;
22
+ delay: z.ZodOptional<z.ZodNumber>;
23
+ }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
24
+ couch: z.ZodString;
25
+ retries: z.ZodOptional<z.ZodNumber>;
26
+ delay: z.ZodOptional<z.ZodNumber>;
27
+ }, z.ZodTypeAny, "passthrough">>, z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>], z.ZodUnknown>, z.ZodPromise<z.ZodObject<{
28
+ ok: z.ZodOptional<z.ZodBoolean>;
29
+ error: z.ZodOptional<z.ZodString>;
30
+ statusCode: z.ZodNumber;
31
+ id: z.ZodOptional<z.ZodString>;
32
+ rev: z.ZodOptional<z.ZodString>;
33
+ }, "strip", z.ZodTypeAny, {
34
+ statusCode: number;
35
+ ok?: boolean | undefined;
36
+ error?: string | undefined;
37
+ id?: string | undefined;
38
+ rev?: string | undefined;
39
+ }, {
40
+ statusCode: number;
41
+ ok?: boolean | undefined;
42
+ error?: string | undefined;
43
+ id?: string | undefined;
44
+ rev?: string | undefined;
45
+ }>>>;
46
+ import { z } from 'zod';
47
+ //# sourceMappingURL=patch.d.mts.map
package/schema/patch.d.mts.map ADDED
@@ -0,0 +1 @@
1
+ {"version":3,"file":"patch.d.mts","sourceRoot":"","sources":["patch.mjs"],"names":[],"mappings":"AAIA;;;;;;;;;;;;iCAGE;AAEF,iEAA4D;AAE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAMuC;kBAjBrB,KAAK"}
package/schema/patch.mjs CHANGED
@@ -9,7 +9,7 @@ export const PatchConfig = CouchConfig.extend({
9
9
 
10
10
  export const PatchProperties = z.record(z.string(), z.any())
11
11
 
12
- export const CouchPatch = z.function()
12
+ export const Patch = z.function()
13
13
  .args(
14
14
  PatchConfig,
15
15
  z.string().describe('the couch doc id'),
package/schema/query.d.mts ADDED
@@ -0,0 +1,151 @@
1
+ export const SimpleViewQueryResponse: z.ZodObject<{
2
+ error: z.ZodOptional<z.ZodString>;
3
+ rows: z.ZodArray<z.ZodObject<{
4
+ id: z.ZodOptional<z.ZodString>;
5
+ key: z.ZodNullable<z.ZodAny>;
6
+ value: z.ZodNullable<z.ZodAny>;
7
+ doc: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
8
+ }, "strip", z.ZodTypeAny, {
9
+ id?: string | undefined;
10
+ key?: any;
11
+ value?: any;
12
+ doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
13
+ }, {
14
+ id?: string | undefined;
15
+ key?: any;
16
+ value?: any;
17
+ doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
18
+ }>, "many">;
19
+ }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
20
+ error: z.ZodOptional<z.ZodString>;
21
+ rows: z.ZodArray<z.ZodObject<{
22
+ id: z.ZodOptional<z.ZodString>;
23
+ key: z.ZodNullable<z.ZodAny>;
24
+ value: z.ZodNullable<z.ZodAny>;
25
+ doc: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
26
+ }, "strip", z.ZodTypeAny, {
27
+ id?: string | undefined;
28
+ key?: any;
29
+ value?: any;
30
+ doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
31
+ }, {
32
+ id?: string | undefined;
33
+ key?: any;
34
+ value?: any;
35
+ doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
36
+ }>, "many">;
37
+ }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
38
+ error: z.ZodOptional<z.ZodString>;
39
+ rows: z.ZodArray<z.ZodObject<{
40
+ id: z.ZodOptional<z.ZodString>;
41
+ key: z.ZodNullable<z.ZodAny>;
42
+ value: z.ZodNullable<z.ZodAny>;
43
+ doc: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
44
+ }, "strip", z.ZodTypeAny, {
45
+ id?: string | undefined;
46
+ key?: any;
47
+ value?: any;
48
+ doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
49
+ }, {
50
+ id?: string | undefined;
51
+ key?: any;
52
+ value?: any;
53
+ doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
54
+ }>, "many">;
55
+ }, z.ZodTypeAny, "passthrough">>;
56
+ export const SimpleViewQuery: z.ZodFunction<z.ZodTuple<[z.ZodObject<{
57
+ couch: z.ZodString;
58
+ }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
59
+ couch: z.ZodString;
60
+ }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
61
+ couch: z.ZodString;
62
+ }, z.ZodTypeAny, "passthrough">>, z.ZodString, z.ZodOptional<z.ZodObject<{
63
+ startkey: z.ZodOptional<z.ZodAny>;
64
+ endkey: z.ZodOptional<z.ZodAny>;
65
+ descending: z.ZodOptional<z.ZodBoolean>;
66
+ skip: z.ZodOptional<z.ZodNumber>;
67
+ limit: z.ZodOptional<z.ZodNumber>;
68
+ key: z.ZodOptional<z.ZodAny>;
69
+ include_docs: z.ZodOptional<z.ZodBoolean>;
70
+ reduce: z.ZodOptional<z.ZodBoolean>;
71
+ group: z.ZodOptional<z.ZodBoolean>;
72
+ group_level: z.ZodOptional<z.ZodNumber>;
73
+ }, "strip", z.ZodTypeAny, {
74
+ startkey?: any;
75
+ endkey?: any;
76
+ descending?: boolean | undefined;
77
+ skip?: number | undefined;
78
+ limit?: number | undefined;
79
+ key?: any;
80
+ include_docs?: boolean | undefined;
81
+ reduce?: boolean | undefined;
82
+ group?: boolean | undefined;
83
+ group_level?: number | undefined;
84
+ }, {
85
+ startkey?: any;
86
+ endkey?: any;
87
+ descending?: boolean | undefined;
88
+ skip?: number | undefined;
89
+ limit?: number | undefined;
90
+ key?: any;
91
+ include_docs?: boolean | undefined;
92
+ reduce?: boolean | undefined;
93
+ group?: boolean | undefined;
94
+ group_level?: number | undefined;
95
+ }>>], z.ZodUnknown>, z.ZodPromise<z.ZodObject<{
96
+ error: z.ZodOptional<z.ZodString>;
97
+ rows: z.ZodArray<z.ZodObject<{
98
+ id: z.ZodOptional<z.ZodString>;
99
+ key: z.ZodNullable<z.ZodAny>;
100
+ value: z.ZodNullable<z.ZodAny>;
101
+ doc: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
102
+ }, "strip", z.ZodTypeAny, {
103
+ id?: string | undefined;
104
+ key?: any;
105
+ value?: any;
106
+ doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
107
+ }, {
108
+ id?: string | undefined;
109
+ key?: any;
110
+ value?: any;
111
+ doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
112
+ }>, "many">;
113
+ }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
114
+ error: z.ZodOptional<z.ZodString>;
115
+ rows: z.ZodArray<z.ZodObject<{
116
+ id: z.ZodOptional<z.ZodString>;
117
+ key: z.ZodNullable<z.ZodAny>;
118
+ value: z.ZodNullable<z.ZodAny>;
119
+ doc: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
120
+ }, "strip", z.ZodTypeAny, {
121
+ id?: string | undefined;
122
+ key?: any;
123
+ value?: any;
124
+ doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
125
+ }, {
126
+ id?: string | undefined;
127
+ key?: any;
128
+ value?: any;
129
+ doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
130
+ }>, "many">;
131
+ }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
132
+ error: z.ZodOptional<z.ZodString>;
133
+ rows: z.ZodArray<z.ZodObject<{
134
+ id: z.ZodOptional<z.ZodString>;
135
+ key: z.ZodNullable<z.ZodAny>;
136
+ value: z.ZodNullable<z.ZodAny>;
137
+ doc: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
138
+ }, "strip", z.ZodTypeAny, {
139
+ id?: string | undefined;
140
+ key?: any;
141
+ value?: any;
142
+ doc?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
143
+ }, {
144
+ id?: string | undefined;
145
+ key?: any;
146
+ value?: any;
147
+ doc?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
148
+ }>, "many">;
149
+ }, z.ZodTypeAny, "passthrough">>>>;
150
+ import { z } from 'zod';
151
+ //# sourceMappingURL=query.d.mts.map
package/schema/query.d.mts.map ADDED
@@ -0,0 +1 @@
1
+ {"version":3,"file":"query.d.mts","sourceRoot":"","sources":["query.mjs"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAQgB;AAEhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCAe6C;kBA5B3B,KAAK"}