@wener/common 1.0.5 → 2.0.1

package/lib/tools/generateSchema.js

@@ -1,43 +1,201 @@
-import { exec } from "node:child_process";
-import fs from "node:fs/promises";
-import path from "node:path";
-import * as Codegen from "@sinclair/typebox-codegen";
-export async function generateSchema({ file, dir = path.dirname(file) }) {
-    const fn = path.basename(file).replace(/\.d\.ts$/, '.ts');
-    const types = await fs.readFile(file, 'utf-8');
-    const typeboxDir = path.join(dir, 'typebox');
-    const zodDir = path.join(dir, 'zod');
-    await fs.mkdir(typeboxDir, {
-        recursive: true
-    });
-    await fs.mkdir(zodDir, {
-        recursive: true
-    });
-    const typeBoxFile = path.join(typeboxDir, fn);
-    const zodFile = path.join(zodDir, fn);
-    {
-        // avoid import type error
-        let out = Codegen.TypeScriptToTypeBox.Generate(types);
-        out = out.replace(/^import \{ Type, Static\b/, `import { Type, type Static`);
-        await fs.writeFile(typeBoxFile, out);
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
     }
-    const model = Codegen.TypeScriptToModel.Generate(types);
-    await fs.writeFile(zodFile, Codegen.ModelToZod.Generate(model));
-    await new Promise((resolve, reject)=>{
-        exec(`pnpm prettier --write "${dir}/{typebox,zod}/*.ts"`, (error, stdout, stderr)=>{
-            if (error) {
-                console.error(`exec error: ${error}`);
-                reject(error);
-                return;
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+import { exec } from 'node:child_process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import * as Codegen from '@sinclair/typebox-codegen';
+export function generateSchema(_0) {
+    return _async_to_generator(function(param) {
+        var file, _param_dir, dir, fn, types, typeboxDir, zodDir, typeBoxFile, zodFile, out, model;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    file = param.file, _param_dir = param.dir, dir = _param_dir === void 0 ? path.dirname(file) : _param_dir;
+                    fn = path.basename(file).replace(/\.d\.ts$/, '.ts');
+                    return [
+                        4,
+                        fs.readFile(file, 'utf-8')
+                    ];
+                case 1:
+                    types = _state.sent();
+                    typeboxDir = path.join(dir, 'typebox');
+                    zodDir = path.join(dir, 'zod');
+                    return [
+                        4,
+                        fs.mkdir(typeboxDir, {
+                            recursive: true
+                        })
+                    ];
+                case 2:
+                    _state.sent();
+                    return [
+                        4,
+                        fs.mkdir(zodDir, {
+                            recursive: true
+                        })
+                    ];
+                case 3:
+                    _state.sent();
+                    typeBoxFile = path.join(typeboxDir, fn);
+                    zodFile = path.join(zodDir, fn);
+                    // avoid import type error
+                    out = Codegen.TypeScriptToTypeBox.Generate(types);
+                    out = out.replace(/^import \{ Type, Static\b/, "import { Type, type Static");
+                    return [
+                        4,
+                        fs.writeFile(typeBoxFile, out)
+                    ];
+                case 4:
+                    _state.sent();
+                    model = Codegen.TypeScriptToModel.Generate(types);
+                    return [
+                        4,
+                        fs.writeFile(zodFile, Codegen.ModelToZod.Generate(model))
+                    ];
+                case 5:
+                    _state.sent();
+                    return [
+                        4,
+                        new Promise(function(resolve, reject) {
+                            exec('pnpm prettier --write "'.concat(dir, '/{typebox,zod}/*.ts"'), function(error, stdout, stderr) {
+                                if (error) {
+                                    console.error("exec error: ".concat(error));
+                                    reject(error);
+                                    return;
+                                }
+                                resolve({
+                                    stderr: stderr,
+                                    stdout: stdout
+                                });
+                                stdout && console.log("prettier:stdout: ".concat(stdout));
+                                stderr && console.error("prettier:stderr: ".concat(stderr));
+                            });
+                        })
+                    ];
+                case 6:
+                    _state.sent();
+                    return [
+                        2
+                    ];
             }
-            resolve({
-                stderr,
-                stdout
-            });
-            stdout && console.log(`prettier:stdout: ${stdout}`);
-            stderr && console.error(`prettier:stderr: ${stderr}`);
         });
-    });
+    }).apply(this, arguments);
 }
-
-//# sourceMappingURL=generateSchema.js.map

package/lib/tools/renderJsonSchemaToMarkdownDoc.js

@@ -1,85 +1,173 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
 export function renderJsonSchemaToMarkdownDoc(rootSchema) {
     // markdown
-    const out = [];
-    const all = new Set();
-    const pending = [];
-    const addObject = (o)=>{
+    var out = [];
+    var all = new Set();
+    var pending = [];
+    var addObject = function(o) {
         if (all.has(o.$id)) {
             return;
         }
         all.add(o.$id);
         pending.push(o);
     };
-    const writeObjectProps = (T, { prefix = '' } = {})=>{
-        if (!T?.properties) {
+    var writeObjectProps = function(T) {
+        var _ref = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, _ref_prefix = _ref.prefix, prefix = _ref_prefix === void 0 ? '' : _ref_prefix;
+        if (!(T === null || T === void 0 ? void 0 : T.properties)) {
             return;
         }
-        for (const [name, schema] of Object.entries(T.properties)){
-            let typ = schema.$id || schema.type;
-            if (typ === 'array') {
-                typ = `${schema.items.$id || schema.items.type}[]`;
-                if (schema.items.$id) {
-                    addObject(schema.items);
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = Object.entries(T.properties)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var _step_value = _sliced_to_array(_step.value, 2), name = _step_value[0], schema = _step_value[1];
+                var typ = schema.$id || schema.type;
+                if (typ === 'array') {
+                    typ = "".concat(schema.items.$id || schema.items.type, "[]");
+                    if (schema.items.$id) {
+                        addObject(schema.items);
+                    }
+                } else if (schema.$id) {
+                    addObject(schema);
                 }
-            } else if (schema.$id) {
-                addObject(schema);
-            }
-            if (!typ) {
-                if ('anyOf' in schema) {
-                    typ = 'enum';
+                if (!typ) {
+                    if ('anyOf' in schema) {
+                        typ = 'enum';
+                    }
                 }
-            }
-            out.push(`| ${prefix}${name} | ${typ} | ${schema.title || schema.description || ''} |`);
-            if (typ === 'object') {
-                writeObjectProps(schema, {
-                    prefix: `${prefix}${name}.`
-                });
-            } else if (schema.type === 'array') {
-                if (schema.items.type === 'object' && !schema.items.$id) {
-                    writeObjectProps(schema.items, {
-                        prefix: `${prefix}${name}[].`
+                out.push("| ".concat(prefix).concat(name, " | ").concat(typ, " | ").concat(schema.title || schema.description || '', " |"));
+                if (typ === 'object') {
+                    writeObjectProps(schema, {
+                        prefix: "".concat(prefix).concat(name, ".")
                     });
+                } else if (schema.type === 'array') {
+                    if (schema.items.type === 'object' && !schema.items.$id) {
+                        writeObjectProps(schema.items, {
+                            prefix: "".concat(prefix).concat(name, "[].")
+                        });
+                    }
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
                 }
             }
         }
     };
-    const writeObject = (T)=>{
-        out.push(`### ${T.title || T.$id}`);
-        out.push(`
-| $id | 名字 |
-| --- | --- |
-| ${T.$id || ''} | ${T.title || ''} | 
-    `);
+    var writeObject = function(T) {
+        out.push("### ".concat(T.title || T.$id));
+        out.push("\n| $id | 名字 |\n| --- | --- |\n| ".concat(T.$id || '', " | ").concat(T.title || '', " | \n    "));
         if (T.description) {
             out.push('');
-            out.push(`> ${T.description}`);
+            out.push("> ".concat(T.description));
             out.push('');
         }
-        out.push(`| 名字 | 类型 | 说明 |`);
-        out.push(`| --- | --- | --- |`);
+        out.push("| 名字 | 类型 | 说明 |");
+        out.push("| --- | --- | --- |");
         writeObjectProps(T);
         out.push('');
     };
     writeObject(rootSchema);
-    for (const schema of pending){
-        if (schema.type === 'object') {
-            writeObject(schema);
-        } else if ('anyOf' in schema) {
-            out.push(`### ${schema.$id || schema.title}`);
-            out.push(`
-| $id | 名字 |
-| --- | --- |
-| ${schema.$id || ''} | ${schema.title || ''} | 
-    `);
-            out.push(`| 值 |  说明 |`);
-            out.push(`| --- | --- |`);
-            for (const item of schema.anyOf){
-                out.push(`| ${item.const} | ${item.title || item.description || ''} |`);
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = pending[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var schema = _step.value;
+            if (schema.type === 'object') {
+                writeObject(schema);
+            } else if ('anyOf' in schema) {
+                out.push("### ".concat(schema.$id || schema.title));
+                out.push("\n| $id | 名字 |\n| --- | --- |\n| ".concat(schema.$id || '', " | ").concat(schema.title || '', " | \n    "));
+                out.push("| 值 |  说明 |");
+                out.push("| --- | --- |");
+                var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                try {
+                    for(var _iterator1 = schema.anyOf[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                        var item = _step1.value;
+                        out.push("| ".concat(item.const, " | ").concat(item.title || item.description || '', " |"));
+                    }
+                } catch (err) {
+                    _didIteratorError1 = true;
+                    _iteratorError1 = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                            _iterator1.return();
+                        }
+                    } finally{
+                        if (_didIteratorError1) {
+                            throw _iteratorError1;
+                        }
+                    }
+                }
+                out.push('');
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
             }
-            out.push('');
         }
     }
     return out.join('\n');
 }
-
-//# sourceMappingURL=renderJsonSchemaToMarkdownDoc.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wener/common",
-  "version": "1.0.5",
+  "version": "2.0.1",
   "type": "module",
   "description": "",
   "author": "",
@@ -34,6 +34,14 @@
       "types": "./src/password/index.ts",
       "default": "./lib/password/index.js"
     },
+    "./resource": {
+      "types": "./src/resource/index.ts",
+      "default": "./lib/resource/index.js"
+    },
+    "./schema": {
+      "types": "./src/schema/index.ts",
+      "default": "./lib/schema/index.js"
+    },
     "./search": {
       "types": "./src/search/index.ts",
       "default": "./lib/search/index.js"
@@ -47,30 +55,34 @@
     "src"
   ],
   "keywords": [],
+  "peerDependencies": {
+    "zod": "*"
+  },
   "dependencies": {
-    "es-toolkit": "^1.32.0",
-    "std-env": "^3.8.1",
-    "ts-pattern": "^5.6.2",
-    "zod": "^3.24.2",
-    "@wener/utils": "1.1.51"
+    "@standard-schema/spec": "^1.0.0",
+    "@wener/utils": "^1.1.51",
+    "date-fns": "^4.1.0",
+    "es-toolkit": "^1.37.2",
+    "std-env": "^3.9.0",
+    "ts-pattern": "^5.7.0"
   },
   "devDependencies": {
-    "@sinclair/typebox": "^0.34.28",
-    "@sinclair/typebox-codegen": "^0.10.5",
+    "@sinclair/typebox": "^0.34.33",
+    "@sinclair/typebox-codegen": "^0.11.1",
     "@types/argon2-browser": "^1.18.4",
     "@types/bcrypt": "^5.0.2",
-    "@types/bcryptjs": "^2.4.6",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
     "ajv-i18n": "^4.2.0",
     "ajv-keywords": "^5.1.0",
-    "argon2": "^0.41.1",
+    "argon2": "^0.43.0",
     "argon2-browser": "^1.18.0",
     "bcrypt": "^5.1.1",
     "bcryptjs": "^3.0.2",
     "chalk": "^5.4.1",
     "consola": "^3.4.2",
-    "dayjs": "^1.11.13"
+    "dayjs": "^1.11.13",
+    "zod": "^3.25.63"
   },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"

package/src/data/maybeNumber.ts

@@ -9,9 +9,13 @@ export function maybeNumber(v: MaybeNumber) {
 		case 'number':
 			return v;
 		case 'bigint':
+			if (v > BigInt(Number.MAX_SAFE_INTEGER) || v < BigInt(Number.MIN_SAFE_INTEGER)) {
+				throw new Error(`bigint out of range`);
+			}
 			return Number(v);
 		case 'string':
-			if (v === '') {
+			v = v.trim();
+			if (!v) {
 				return undefined;
 			}
 	}

package/src/data/resolvePagination.test.ts

@@ -53,6 +53,6 @@ test(resolvePagination.name, () => {
 });
 
 test(`${resolvePagination.name} with options`, () => {
-	expect(resolvePagination({ pageSize: '200' }, { maxPageSize: 50 })).toMatchObject({ pageSize: 50, limit: 50 });
+	expect(resolvePagination({ pageSize: '200' }, { maxLimit: 50 })).toMatchObject({ pageSize: 50, limit: 50 });
 	expect(resolvePagination({}, { pageSize: 30 })).toMatchObject({ pageSize: 30, limit: 30 });
 });

package/src/data/resolvePagination.ts

@@ -1,5 +1,5 @@
 import { maybeFunction, type MaybeFunction } from '@wener/utils';
-import { clamp, mapValues, omitBy, pick } from 'es-toolkit';
+import { mapValues, omitBy, pick } from 'es-toolkit';
 import { maybeNumber, type MaybeNumber } from './maybeNumber';
 
 export type PaginationInput = {
@@ -22,7 +22,8 @@ export function resolvePagination(
 	page: PaginationInput,
 	options: {
 		pageSize?: MaybeFunction<number, [number | undefined]>;
-		maxPageSize?: number;
+		maxLimit?: number;
+		maxOffset?: number;
 	} = {},
 ): ResolvedPagination {
 	let out = omitBy(
@@ -38,15 +39,23 @@ export function resolvePagination(
 	if (options.pageSize) {
 		pageSize = maybeFunction(options.pageSize, pageSize);
 	}
-	pageSize ??= 20;
-	pageSize = clamp(pageSize, 1, options.maxPageSize ?? 1000);
+	pageSize ??= resolvePagination.pageSize;
 
-	let { pageNumber = 1, pageIndex, limit, offset } = out;
+	let { pageNumber = 1, pageIndex } = out;
 	// page index over page number
 	pageNumber = Math.max(pageNumber, 1);
 	pageIndex = Math.max(pageIndex ?? pageNumber - 1, 0);
-	limit = Math.max(1, limit ?? pageSize);
-	offset = Math.max(0, offset ?? pageSize * pageIndex);
+
+	let { limit = pageSize, offset = pageSize * pageIndex } = out;
+	limit = Math.max(1, limit);
+	offset = Math.max(0, offset);
+
+	if (options.maxLimit) {
+		limit = Math.min(limit, options.maxLimit);
+	}
+	if (options.maxOffset) {
+		offset = Math.min(offset, options.maxOffset);
+	}
 
 	pageSize = limit;
 	pageIndex = Math.floor(offset / pageSize);
@@ -58,3 +67,5 @@ export function resolvePagination(
 		pageIndex,
 	};
 }
+
+resolvePagination.pageSize = 20;

package/src/data/types.d.ts

@@ -31,3 +31,15 @@ type ListResult<T = any> = {
 	/** Total number of items */
 	total: number;
 };
+
+type PageInfo = {
+	/** Whether there are more items */
+	hasNextPage: boolean;
+	/** Whether there are previous items */
+	hasPreviousPage: boolean;
+
+	// /** Start cursor */
+	// startCursor?: string;
+	// /** End cursor */
+	// endCursor?: string;
+};

package/src/jsonschema/JsonSchema.test.ts

@@ -1,5 +1,8 @@
+import type { TObject } from '@sinclair/typebox';
+import type { AnySchemaObject, JSONSchemaType } from 'ajv';
 import { describe, expect, it } from 'vitest';
 import { JsonSchema } from './JsonSchema';
+import type { JsonSchemaDef } from './types';
 
 describe('jsonschema', () => {
 	it('should create from schema', () => {
@@ -15,4 +18,18 @@ describe('jsonschema', () => {
 			expect(JsonSchema.create(a)).toEqual(b);
 		}
 	});
+
+	it('should match typebox types', () => {
+		let a: JsonSchemaDef | undefined;
+		let b: TObject<{}> | undefined;
+		a = b;
+	});
+
+	it('should match ajv types', () => {
+		let a: JsonSchemaDef | undefined;
+		let b: AnySchemaObject | undefined;
+		let c: JSONSchemaType<{}> | undefined;
+		a = b;
+		// a = c;
+	});
 });