@wener/common 2.0.5 → 2.0.6

package/lib/password/createArgon2PasswordAlgorithm.js

@@ -1,53 +1,52 @@
-import { maybeFunction } from "@wener/utils";
-export function createArgon2PasswordAlgorithm({ type, provide = async ()=>{
-    throw new Error('Please provide argon2');
-// const { default: wasm } = await import('argon2-browser/dist/argon2.wasm');
-// const argon2 = await WebAssembly.instantiateStreaming(fetch(wasm), {
-//   env: {
-//     memoryBase: 0,
-//     tableBase: 0,
-//     memory: new WebAssembly.Memory({ initial: 256 }),
-//     table: new WebAssembly.Table({ initial: 0, element: 'anyfunc' }),
-//     __memory_base: 0,
-//     __table_base: 0,
-//   },
-// });
-// console.log(argon2.instance.exports);
-// const { hash } = argon2.instance.exports as any as typeof import('argon2-browser');
-} } = {}) {
-    // 0=Argon2d, 1=Argon2i, 2=Argon2id
-    const toType = {
-        argon2d: 0,
-        argon2i: 1,
-        argon2id: 2
-    };
-    let mod;
-    const resolve = ()=>{
-        if (mod) return mod;
-        return Promise.resolve(maybeFunction(provide)).then((v)=>mod = v);
-    };
-    return {
-        name: 'argon2',
-        ids: [
-            'argon2i',
-            'argon2d',
-            'argon2id'
-        ],
-        async hash (password, opts) {
-            // const { hash } = await import('argon2');
-            const { hash } = await resolve();
-            const id = opts?.id;
-            return hash(password, {
-                salt: opts?.salt ? Buffer.from(opts.salt) : undefined,
-                raw: false,
-                type: toType[id || ''] ?? toType[type || '']
-            });
-        },
-        async verify (password, hash) {
-            const { verify } = await resolve();
-            return verify(hash, password);
-        }
-    };
+import { maybeFunction } from '@wener/utils';
+export function createArgon2PasswordAlgorithm({
+	type,
+	provide = async () => {
+		throw new Error('Please provide argon2');
+		// const { default: wasm } = await import('argon2-browser/dist/argon2.wasm');
+		// const argon2 = await WebAssembly.instantiateStreaming(fetch(wasm), {
+		//   env: {
+		//     memoryBase: 0,
+		//     tableBase: 0,
+		//     memory: new WebAssembly.Memory({ initial: 256 }),
+		//     table: new WebAssembly.Table({ initial: 0, element: 'anyfunc' }),
+		//     __memory_base: 0,
+		//     __table_base: 0,
+		//   },
+		// });
+		// console.log(argon2.instance.exports);
+		// const { hash } = argon2.instance.exports as any as typeof import('argon2-browser');
+	},
+} = {}) {
+	// 0=Argon2d, 1=Argon2i, 2=Argon2id
+	const toType = {
+		argon2d: 0,
+		argon2i: 1,
+		argon2id: 2,
+	};
+	let mod;
+	const resolve = () => {
+		if (mod) return mod;
+		return Promise.resolve(maybeFunction(provide)).then((v) => (mod = v));
+	};
+	return {
+		name: 'argon2',
+		ids: ['argon2i', 'argon2d', 'argon2id'],
+		async hash(password, opts) {
+			// const { hash } = await import('argon2');
+			const { hash } = await resolve();
+			const id = opts?.id;
+			return hash(password, {
+				salt: opts?.salt ? Buffer.from(opts.salt) : undefined,
+				raw: false,
+				type: toType[id || ''] ?? toType[type || ''],
+			});
+		},
+		async verify(password, hash) {
+			const { verify } = await resolve();
+			return verify(hash, password);
+		},
+	};
 }
 
-//# sourceMappingURL=createArgon2PasswordAlgorithm.js.map
+//# sourceMappingURL=createArgon2PasswordAlgorithm.js.map

package/lib/password/createBase64PasswordAlgorithm.js

@@ -1,14 +1,14 @@
-import { ArrayBuffers } from "@wener/utils";
+import { ArrayBuffers } from '@wener/utils';
 export function createBase64PasswordAlgorithm({ id = 'base64' } = {}) {
-    return {
-        name: id,
-        async hash (password) {
-            return `$${id}$$${ArrayBuffers.toBase64(password).replace(/=/g, '')}`;
-        },
-        async verify (password, _hash, opts) {
-            return Boolean(opts.hash) && ArrayBuffers.toString(opts.hash) === password;
-        }
-    };
+	return {
+		name: id,
+		async hash(password) {
+			return `$${id}$$${ArrayBuffers.toBase64(password).replace(/=/g, '')}`;
+		},
+		async verify(password, _hash, opts) {
+			return Boolean(opts.hash) && ArrayBuffers.toString(opts.hash) === password;
+		},
+	};
 }
 
-//# sourceMappingURL=createBase64PasswordAlgorithm.js.map
+//# sourceMappingURL=createBase64PasswordAlgorithm.js.map

package/lib/password/createBcryptPasswordAlgorithm.js

@@ -1,20 +1,22 @@
-export function createBcryptPasswordAlgorithm({ // provider = () => import('bcrypt').then((v) => v.default),
-provider = ()=>import("bcryptjs").then((v)=>v.default) } = {}) {
-    // bcrypt or bcryptjs
-    return {
-        name: 'bcrypt',
-        async hash (password, opts) {
-            const { hash } = await provider();
-            return hash(password, opts?.rounds ?? 10);
-        },
-        async verify (password, hash) {
-            const { compare } = await provider();
-            if (hash.startsWith('$2y$')) {
-                hash = hash.replace(/^\$2y\$/, '$2a$');
-            }
-            return compare(password, hash);
-        }
-    };
+export function createBcryptPasswordAlgorithm({
+	// provider = () => import('bcrypt').then((v) => v.default),
+	provider = () => import('bcryptjs').then((v) => v.default),
+} = {}) {
+	// bcrypt or bcryptjs
+	return {
+		name: 'bcrypt',
+		async hash(password, opts) {
+			const { hash } = await provider();
+			return hash(password, opts?.rounds ?? 10);
+		},
+		async verify(password, hash) {
+			const { compare } = await provider();
+			if (hash.startsWith('$2y$')) {
+				hash = hash.replace(/^\$2y\$/, '$2a$');
+			}
+			return compare(password, hash);
+		},
+	};
 }
 
-//# sourceMappingURL=createBcryptPasswordAlgorithm.js.map
+//# sourceMappingURL=createBcryptPasswordAlgorithm.js.map

package/lib/password/createPBKDF2PasswordAlgorithm.js

@@ -1,54 +1,67 @@
-import { Errors } from "@wener/utils";
-import { PHC } from "./PHC.js";
-export function createPBKDF2PasswordAlgorithm({ id, digest, iterations = 100000, saltlen = 16, keylen = digest === "SHA-256" ? 32 : 64 }) {
-    return {
-        name: id,
-        async hash(password, opts) {
-            let salt;
-            if (opts?.salt) {
-                salt = opts.salt;
-            }
-            else {
-                salt = new Uint8Array(saltlen);
-                crypto.getRandomValues(salt);
-            }
-            const rounds = opts?.rounds ?? iterations;
-            let key = await crypto.subtle.importKey("raw", new TextEncoder().encode(password), "PBKDF2", false, [
-                "deriveBits"
-            ]);
-            let hash = await crypto.subtle.deriveBits({
-                name: "PBKDF2",
-                iterations: rounds,
-                salt: salt,
-                hash: digest
-            }, key, keylen * 8);
-            return PHC.serialize({
-                id: opts?.id ?? id,
-                params: {
-                    rounds
-                },
-                salt,
-                hash: new Uint8Array(hash)
-            });
-        },
-        async verify(password, _, opts) {
-            const rounds = opts?.params?.rounds ?? iterations;
-            const salt = opts.salt;
-            const storedHash = opts.hash;
-            Errors.BadRequest.check(typeof rounds === "number", "Invalid rounds");
-            Errors.BadRequest.check(salt instanceof Uint8Array, "Invalid salt");
-            Errors.BadRequest.check(storedHash instanceof Uint8Array, "Invalid hash");
-            let key = await crypto.subtle.importKey("raw", new TextEncoder().encode(password), "PBKDF2", false, [
-                "deriveBits"
-            ]);
-            let hash = await crypto.subtle.deriveBits({
-                name: "PBKDF2",
-                iterations: rounds,
-                salt: salt,
-                hash: digest
-            }, key, storedHash.length * 8);
-            return new Uint8Array(hash).every((v, i) => v === storedHash?.[i]);
-        }
-    };
+import { Errors } from '@wener/utils';
+import { PHC } from './PHC.js';
+export function createPBKDF2PasswordAlgorithm({
+	id,
+	digest,
+	iterations = 100000,
+	saltlen = 16,
+	keylen = digest === 'SHA-256' ? 32 : 64,
+}) {
+	return {
+		name: id,
+		async hash(password, opts) {
+			let salt;
+			if (opts?.salt) {
+				salt = opts.salt;
+			} else {
+				salt = new Uint8Array(saltlen);
+				crypto.getRandomValues(salt);
+			}
+			const rounds = opts?.rounds ?? iterations;
+			let key = await crypto.subtle.importKey('raw', new TextEncoder().encode(password), 'PBKDF2', false, [
+				'deriveBits',
+			]);
+			let hash = await crypto.subtle.deriveBits(
+				{
+					name: 'PBKDF2',
+					iterations: rounds,
+					salt: salt,
+					hash: digest,
+				},
+				key,
+				keylen * 8,
+			);
+			return PHC.serialize({
+				id: opts?.id ?? id,
+				params: {
+					rounds,
+				},
+				salt,
+				hash: new Uint8Array(hash),
+			});
+		},
+		async verify(password, _, opts) {
+			const rounds = opts?.params?.rounds ?? iterations;
+			const salt = opts.salt;
+			const storedHash = opts.hash;
+			Errors.BadRequest.check(typeof rounds === 'number', 'Invalid rounds');
+			Errors.BadRequest.check(salt instanceof Uint8Array, 'Invalid salt');
+			Errors.BadRequest.check(storedHash instanceof Uint8Array, 'Invalid hash');
+			let key = await crypto.subtle.importKey('raw', new TextEncoder().encode(password), 'PBKDF2', false, [
+				'deriveBits',
+			]);
+			let hash = await crypto.subtle.deriveBits(
+				{
+					name: 'PBKDF2',
+					iterations: rounds,
+					salt: salt,
+					hash: digest,
+				},
+				key,
+				storedHash.length * 8,
+			);
+			return new Uint8Array(hash).every((v, i) => v === storedHash?.[i]);
+		},
+	};
 }
 //# sourceMappingURL=createPBKDF2PasswordAlgorithm.js.map

package/lib/password/createScryptPasswordAlgorithm.js

@@ -1,66 +1,77 @@
-import { randomBytes, scrypt, timingSafeEqual } from "node:crypto";
-import { Errors } from "@wener/utils";
-import { PHC } from "./PHC.js";
+import { randomBytes, scrypt, timingSafeEqual } from 'node:crypto';
+import { Errors } from '@wener/utils';
+import { PHC } from './PHC.js';
 export function createScryptPasswordAlgorithm(options = {}) {
-    let id = options.id || "scrypt";
-    options.cost ||= 2 ** 14;
-    options.blocksize ||= 8;
-    options.parallelism ||= 1;
-    options.saltlen ||= 16;
-    options.keylen ||= 32;
-    return {
-        name: id,
-        async hash(password, opts) {
-            const salt = opts?.salt || randomBytes(options.saltlen);
-            return new Promise((resolve, reject) => {
-                let N = options.cost;
-                let r = options.blocksize;
-                let p = options.parallelism;
-                scrypt(password, salt, options.keylen, {
-                    N,
-                    r,
-                    p
-                }, (err, derivedKey) => {
-                    if (err)
-                        return reject(err);
-                    resolve(PHC.serialize({
-                        id: opts?.id ?? id,
-                        params: {
-                            ln: N,
-                            r: r,
-                            p: p
-                        },
-                        salt,
-                        hash: derivedKey
-                    }));
-                });
-            });
-        },
-        async verify(password, _hash, opts) {
-            try {
-                const salt = Errors.BadRequest.require(opts.salt);
-                const storedHash = Errors.BadRequest.require(opts.hash);
-                const N = parseInt(opts.params?.ln, 10);
-                const r = parseInt(opts.params?.r, 10);
-                const p = parseInt(opts.params?.p, 10);
-                const keylen = storedHash.length;
-                return new Promise((resolve, reject) => {
-                    scrypt(password, salt, keylen, {
-                        N,
-                        r,
-                        p
-                    }, (err, derivedKey) => {
-                        if (err)
-                            return reject(err);
-                        const isMatch = timingSafeEqual(derivedKey, storedHash);
-                        resolve(isMatch);
-                    });
-                });
-            }
-            catch (_error) {
-                return Promise.resolve(false);
-            }
-        }
-    };
+	let id = options.id || 'scrypt';
+	options.cost ||= 2 ** 14;
+	options.blocksize ||= 8;
+	options.parallelism ||= 1;
+	options.saltlen ||= 16;
+	options.keylen ||= 32;
+	return {
+		name: id,
+		async hash(password, opts) {
+			const salt = opts?.salt || randomBytes(options.saltlen);
+			return new Promise((resolve, reject) => {
+				let N = options.cost;
+				let r = options.blocksize;
+				let p = options.parallelism;
+				scrypt(
+					password,
+					salt,
+					options.keylen,
+					{
+						N,
+						r,
+						p,
+					},
+					(err, derivedKey) => {
+						if (err) return reject(err);
+						resolve(
+							PHC.serialize({
+								id: opts?.id ?? id,
+								params: {
+									ln: N,
+									r: r,
+									p: p,
+								},
+								salt,
+								hash: derivedKey,
+							}),
+						);
+					},
+				);
+			});
+		},
+		async verify(password, _hash, opts) {
+			try {
+				const salt = Errors.BadRequest.require(opts.salt);
+				const storedHash = Errors.BadRequest.require(opts.hash);
+				const N = parseInt(opts.params?.ln, 10);
+				const r = parseInt(opts.params?.r, 10);
+				const p = parseInt(opts.params?.p, 10);
+				const keylen = storedHash.length;
+				return new Promise((resolve, reject) => {
+					scrypt(
+						password,
+						salt,
+						keylen,
+						{
+							N,
+							r,
+							p,
+						},
+						(err, derivedKey) => {
+							if (err) return reject(err);
+							const isMatch = timingSafeEqual(derivedKey, storedHash);
+							resolve(isMatch);
+						},
+					);
+				});
+			} catch (_error) {
+				return Promise.resolve(false);
+			}
+		},
+	};
 }
 //# sourceMappingURL=createScryptPasswordAlgorithm.js.map

package/lib/password/index.js

@@ -1,6 +1,6 @@
-export { PHC } from "./PHC.js";
-export { Password } from "./Password.js";
-export { createArgon2PasswordAlgorithm } from "./createArgon2PasswordAlgorithm.js";
-export { createBase64PasswordAlgorithm } from "./createBase64PasswordAlgorithm.js";
-export { createBcryptPasswordAlgorithm } from "./createBcryptPasswordAlgorithm.js";
+export { createArgon2PasswordAlgorithm } from './createArgon2PasswordAlgorithm.js';
+export { createBase64PasswordAlgorithm } from './createBase64PasswordAlgorithm.js';
+export { createBcryptPasswordAlgorithm } from './createBcryptPasswordAlgorithm.js';
+export { Password } from './Password.js';
+export { PHC } from './PHC.js';
 //# sourceMappingURL=index.js.map

package/lib/password/server/index.js

@@ -1,2 +1,2 @@
-export { createScryptPasswordAlgorithm } from "../createScryptPasswordAlgorithm.js";
+export { createScryptPasswordAlgorithm } from '../createScryptPasswordAlgorithm.js';
 //# sourceMappingURL=index.js.map

package/lib/resource/Identifiable.js

@@ -1,3 +1,3 @@
-export { };
+export {};
 
-//# sourceMappingURL=Identifiable.js.map
+//# sourceMappingURL=Identifiable.js.map

package/lib/resource/ListQuery.js

@@ -1,47 +1,47 @@
-import { z } from "zod/v4";
-const IntLikeSchema = z.coerce.number().multipleOf(1).min(0).optional().overwrite((v)=>v || undefined);
+import { z } from 'zod/v4';
+
+const IntLikeSchema = z.coerce
+	.number()
+	.multipleOf(1)
+	.min(0)
+	.optional()
+	.overwrite((v) => v || undefined);
 export const ListQuerySchema = z.object({
-    id: z.coerce.string().optional(),
-    ids: z.array(z.coerce.string()).optional(),
-    filter: z.string().optional().describe('sql-like filter string'),
-    filters: z.array(z.any()).optional().describe('sql-like filter string'),
-    where: z.record(z.string(), z.any()).optional().describe('document query filter'),
-    search: z.string().optional(),
-    limit: IntLikeSchema,
-    offset: IntLikeSchema,
-    order: z.array(z.string()).optional().describe('order like "a,-b,c desc null last"'),
-    pageIndex: IntLikeSchema.describe('0-based page index'),
-    pageNumber: IntLikeSchema.describe('1-based page number'),
-    pageSize: IntLikeSchema,
-    cursor: z.string().optional(),
-    deleted: z.coerce.boolean().optional()
+	id: z.coerce.string().optional(),
+	ids: z.array(z.coerce.string()).optional(),
+	filter: z.string().optional().describe('sql-like filter string'),
+	filters: z.array(z.any()).optional().describe('sql-like filter string'),
+	where: z.record(z.string(), z.any()).optional().describe('document query filter'),
+	search: z.string().optional(),
+	limit: IntLikeSchema,
+	offset: IntLikeSchema,
+	order: z.array(z.string()).optional().describe('order like "a,-b,c desc null last"'),
+	pageIndex: IntLikeSchema.describe('0-based page index'),
+	pageNumber: IntLikeSchema.describe('1-based page number'),
+	pageSize: IntLikeSchema,
+	cursor: z.string().optional(),
+	deleted: z.coerce.boolean().optional(),
 });
 export function resolveListQuery(target, ...args) {
-    let out = args.reduce((a, source)=>{
-        if (typeof source === 'function') {
-            const result = source(a);
-            // do not use the result as merge source
-            return result || a;
-        }
-        let b = source;
-        if (!b) return a;
-        // do not resolve id to ids
-        let ids = [
-            ...a.ids || [],
-            ...b.ids || []
-        ];
-        return {
-            ...a,
-            ...b,
-            ids: ids,
-            filters: [
-                ...a.filters || [],
-                ...b.filters || []
-            ],
-            search: b.search || a.search
-        };
-    }, target || {});
-    return ListQuerySchema.parse(out);
+	let out = args.reduce((a, source) => {
+		if (typeof source === 'function') {
+			const result = source(a);
+			// do not use the result as merge source
+			return result || a;
+		}
+		let b = source;
+		if (!b) return a;
+		// do not resolve id to ids
+		let ids = [...(a.ids || []), ...(b.ids || [])];
+		return {
+			...a,
+			...b,
+			ids: ids,
+			filters: [...(a.filters || []), ...(b.filters || [])],
+			search: b.search || a.search,
+		};
+	}, target || {});
+	return ListQuerySchema.parse(out);
 }
 
-//# sourceMappingURL=ListQuery.js.map
+//# sourceMappingURL=ListQuery.js.map

package/lib/resource/getTitleOfResource.js

@@ -1,8 +1,8 @@
 export function getTitleOfResource(res) {
-    if (res && typeof res === 'object') {
-        return res.displayName || res.title || res.fullName || res.loginName || res.topic || res.code;
-    }
-    return undefined;
+	if (res && typeof res === 'object') {
+		return res.displayName || res.title || res.fullName || res.loginName || res.topic || res.code;
+	}
+	return undefined;
 }
 
-//# sourceMappingURL=getTitleOfResource.js.map
+//# sourceMappingURL=getTitleOfResource.js.map

package/lib/resource/index.js

@@ -1,3 +1,3 @@
-export { getTitleOfResource } from "./getTitleOfResource.js";
-export { resolveListQuery, ListQuerySchema } from "./ListQuery.js";
+export { getTitleOfResource } from './getTitleOfResource.js';
+export { ListQuerySchema, resolveListQuery } from './ListQuery.js';
 //# sourceMappingURL=index.js.map