@authup/server-kit 1.0.0-beta.45 → 1.0.0-beta.47

package/dist/index.mjs

@@ -1,19 +1,133 @@
+import { TTLCache } from "@isaacs/ttlcache";
+import { Client as RedisClient, JsonAdapter, JsonAdapter as RedisJsonAdapter, Watcher as RedisWatcher, buildKeyPath as buildRedisKeyPath, createClient, escapeKey as escapeRedisKey, parseKeyPath as parseRedisKeyPath } from "redis-extension";
+import { isObject } from "smob";
 import { REALM_MASTER_NAME } from "@authup/core-kit";
-import { arrayBufferToBase64, base64ToArrayBuffer, isObject } from "@authup/kit";
+import { arrayBufferToBase64, base64ToArrayBuffer, isObject as isObject$1 } from "@authup/kit";
 import { compare as compare$1, hash as hash$1 } from "@node-rs/bcrypt";
 import { JWKType, JWTAlgorithm, JWTError } from "@authup/specs";
 import { subtle } from "uncrypto";
 import { Algorithm, sign, verify } from "@node-rs/jsonwebtoken";
-import { isObject as isObject$1 } from "smob";
-import { TTLCache } from "@isaacs/ttlcache";
-import { Client as RedisClient, JsonAdapter, JsonAdapter as RedisJsonAdapter, Watcher as RedisWatcher, buildKeyPath as buildRedisKeyPath, createClient, escapeKey as escapeRedisKey, parseKeyPath as parseRedisKeyPath } from "redis-extension";
-import path from "node:path";
-import process from "node:process";
-import { Logger, createLogger as createLogger$1, format, transports } from "winston";
-import { singa } from "singa";
-import { VaultClient, createClient as createVaultClient } from "@hapic/vault";
 import { buildEventFullName } from "@authup/core-realtime-kit";
 import { Emitter } from "@socket.io/redis-emitter";
+import path from "node:path";
+import process from "node:process";
+import { createLogger as createLogger$1, format, transports } from "winston";
+//#region src/cache/adapters/memory.ts
+var MemoryCache = class {
+	instance;
+	constructor(options = {}) {
+		this.instance = new TTLCache({
+			checkAgeOnGet: true,
+			ttl: Infinity,
+			...options || {}
+		});
+	}
+	async pop(key) {
+		if (this.instance.has(key)) {
+			const output = this.instance.get(key);
+			this.instance.delete(key);
+			return output;
+		}
+		return null;
+	}
+	async has(key) {
+		return this.instance.has(key);
+	}
+	async get(key) {
+		const output = await this.instance.get(key);
+		if (output) return output;
+		return null;
+	}
+	async set(key, value, options) {
+		this.instance.set(key, value, { ttl: options.ttl });
+	}
+	async drop(key) {
+		this.instance.delete(key);
+	}
+	async dropMany(keys) {
+		for (const key of keys) this.instance.delete(key);
+	}
+	async clear(options = {}) {
+		if (options.prefix) {
+			const keys = this.instance.keys();
+			let iterator = keys.next();
+			while (!iterator.done) {
+				if (typeof iterator.value !== "string") continue;
+				if (iterator.value.startsWith(options.prefix)) this.instance.delete(iterator.value);
+				iterator = keys.next();
+			}
+			return;
+		}
+		this.instance.clear();
+	}
+};
+//#endregion
+//#region src/redis/check.ts
+function isRedisClient(data) {
+	return isObject(data) && typeof data.connect === "function" && typeof data.disconnect === "function";
+}
+//#endregion
+//#region src/redis/factory.ts
+function createRedisClient(input) {
+	if (typeof input === "boolean") return createClient({ connectionString: "redis://127.0.0.1" });
+	if (typeof input === "string") return createClient({ connectionString: input });
+	if (!isRedisClient(input)) return createClient({ options: input });
+	return input;
+}
+//#endregion
+//#region src/cache/adapters/redis.ts
+var RedisCache = class {
+	client;
+	jsonAdapter;
+	constructor(input) {
+		this.client = createRedisClient(input);
+		this.jsonAdapter = new JsonAdapter(this.client);
+	}
+	async get(key) {
+		const output = await this.jsonAdapter.get(key);
+		if (output) return output;
+		return null;
+	}
+	async pop(key) {
+		const raw = await this.client.getdel(key);
+		if (!raw) return null;
+		try {
+			return JSON.parse(raw);
+		} catch {
+			return null;
+		}
+	}
+	async has(key) {
+		return !!await this.get(key);
+	}
+	async set(key, value, options) {
+		await this.jsonAdapter.set(key, value, { milliseconds: options.ttl });
+	}
+	async drop(key) {
+		await this.jsonAdapter.drop(key);
+	}
+	async dropMany(keys) {
+		const pipeline = this.client.pipeline();
+		for (const key of keys) pipeline.del(key);
+		await pipeline.exec();
+	}
+	async clear(options = {}) {
+		if (options.prefix) {
+			const pipeline = this.client.pipeline();
+			const keys = await this.client.keys(`${options.prefix}*`);
+			for (const key of keys) pipeline.del(key);
+			await pipeline.exec();
+			return;
+		}
+		await this.client.flushdb();
+	}
+};
+//#endregion
+//#region src/cache/helper.ts
+function buildCacheKey(options) {
+	return buildRedisKeyPath(options);
+}
+//#endregion
 //#region src/core/service.ts
 var AbstractEntityService = class {
 	isActorMasterRealmMember(actor) {
@@ -26,7 +140,7 @@ var AbstractEntityService = class {
 		if (!actor.identity) return;
 		const { data } = actor.identity;
 		if (data.realm_id) return data.realm_id;
-		if (isObject(data.realm) && data.realm.id) return data.realm.id;
+		if (isObject$1(data.realm) && data.realm.id) return data.realm.id;
 	}
 };
 //#endregion
@@ -351,7 +465,7 @@ function extractTokenPayload(token) {
 //#endregion
 //#region src/crypto/json-web-token/utils.ts
 function createErrorForJWTError(e) {
-	if (isObject$1(e)) {
+	if (isObject(e)) {
 		if (typeof e.name === "string") switch (e.name) {
 			case "TokenExpiredError": return JWTError.expired();
 			case "NotBeforeError":
@@ -481,204 +595,13 @@ async function verifyToken(token, context) {
 	return output;
 }
 //#endregion
-//#region src/domain-event/module.ts
-var DomainEventPublisher = class {
-	publishers;
-	constructor() {
-		this.publishers = /* @__PURE__ */ new Set();
-	}
-	mount(publisher) {
-		this.publishers.add(publisher);
-	}
-	async publish(ctx) {
-		const publishers = this.publishers.values();
-		while (true) {
-			const it = publishers.next();
-			if (it.done) return;
-			await it.value.publish(ctx);
-		}
-	}
-};
-//#endregion
-//#region src/services/cache/adapters/memory.ts
-var MemoryCache = class {
-	instance;
-	constructor(options = {}) {
-		this.instance = new TTLCache({
-			checkAgeOnGet: true,
-			ttl: Infinity,
-			...options || {}
-		});
-	}
-	async pop(key) {
-		if (this.instance.has(key)) {
-			const output = this.instance.get(key);
-			this.instance.delete(key);
-			return output;
-		}
-		return null;
-	}
-	async has(key) {
-		return this.instance.has(key);
-	}
-	async get(key) {
-		const output = await this.instance.get(key);
-		if (output) return output;
-		return null;
-	}
-	async set(key, value, options) {
-		this.instance.set(key, value, { ttl: options.ttl });
-	}
-	async drop(key) {
-		this.instance.delete(key);
-	}
-	async dropMany(keys) {
-		for (const key of keys) this.instance.delete(key);
-	}
-	async clear(options = {}) {
-		if (options.prefix) {
-			const keys = this.instance.keys();
-			let iterator = keys.next();
-			while (!iterator.done) {
-				if (typeof iterator.value !== "string") continue;
-				if (iterator.value.startsWith(options.prefix)) this.instance.delete(iterator.value);
-				iterator = keys.next();
-			}
-			return;
-		}
-		this.instance.clear();
-	}
-};
-//#endregion
-//#region src/services/redis/check.ts
-function isRedisClient(data) {
-	return isObject$1(data) && typeof data.connect === "function" && typeof data.disconnect === "function";
-}
-//#endregion
-//#region src/services/redis/factory.ts
-function createRedisClient(input) {
-	if (typeof input === "boolean") return createClient({ connectionString: "redis://127.0.0.1" });
-	if (typeof input === "string") return createClient({ connectionString: input });
-	if (!isRedisClient(input)) return createClient({ options: input });
-	return input;
-}
-//#endregion
-//#region src/services/cache/adapters/redis.ts
-var RedisCache = class {
-	client;
-	jsonAdapter;
-	constructor(input) {
-		this.client = createRedisClient(input);
-		this.jsonAdapter = new JsonAdapter(this.client);
-	}
-	async get(key) {
-		const output = await this.jsonAdapter.get(key);
-		if (output) return output;
-		return null;
-	}
-	async pop(key) {
-		const raw = await this.client.getdel(key);
-		if (!raw) return null;
-		try {
-			return JSON.parse(raw);
-		} catch {
-			return null;
-		}
-	}
-	async has(key) {
-		return !!await this.get(key);
-	}
-	async set(key, value, options) {
-		await this.jsonAdapter.set(key, value, { milliseconds: options.ttl });
-	}
-	async drop(key) {
-		await this.jsonAdapter.drop(key);
-	}
-	async dropMany(keys) {
-		const pipeline = this.client.pipeline();
-		for (const key of keys) pipeline.del(key);
-		await pipeline.exec();
-	}
-	async clear(options = {}) {
-		if (options.prefix) {
-			const pipeline = this.client.pipeline();
-			const keys = await this.client.keys(`${options.prefix}*`);
-			for (const key of keys) pipeline.del(key);
-			await pipeline.exec();
-			return;
-		}
-		await this.client.flushdb();
-	}
-};
-//#endregion
-//#region src/services/cache/helper.ts
-function buildCacheKey(options) {
-	return buildRedisKeyPath(options);
-}
-//#endregion
-//#region src/services/logger/module.ts
-function createNoopLogger() {
-	return createLogger$1({ silent: true });
-}
-function createLogger(context) {
-	let items;
-	const cwd = context.directory || process.cwd();
-	if (context.env === "production") items = [
-		new transports.Console({ level: "info" }),
-		new transports.File({
-			filename: path.join(cwd, "http.log"),
-			level: "http",
-			maxsize: 10 * 1024 * 1024,
-			maxFiles: 5
-		}),
-		new transports.File({
-			filename: path.join(cwd, "error.log"),
-			level: "warn",
-			maxsize: 10 * 1024 * 1024,
-			maxFiles: 5
-		})
-	];
-	else items = [new transports.Console({ level: "debug" })];
-	return createLogger$1({
-		format: format.combine(format.errors({ stack: true }), format.timestamp(), format.colorize(), format.simple()),
-		transports: items
-	});
-}
-//#endregion
-//#region src/services/logger/singleton.ts
-const instance$1 = singa({ name: "logger" });
-function setLoggerFactory(factory) {
-	instance$1.setFactory(factory);
-}
-function isLoggerUsable() {
-	return instance$1.has() || instance$1.hasFactory();
-}
-function setLogger(input) {
-	instance$1.set(input);
-}
-function useLogger() {
-	return instance$1.use();
-}
-//#endregion
-//#region src/services/vault/singleton.ts
-const instance = singa({ name: "vault" });
-function setVaultFactory(factory) {
-	instance.setFactory(factory);
-}
-function isVaultClientUsable() {
-	return instance.has() || instance.hasFactory();
-}
-function useVaultClient() {
-	return instance.use();
-}
-//#endregion
 //#region src/domain-event/utils.ts
 function transformDomainEventData(input) {
 	const keys = Object.keys(input);
 	for (const key_ of keys) {
 		const key = key_;
 		const value = input[key];
-		if (!isObject(value)) continue;
+		if (!isObject$1(value)) continue;
 		if (value instanceof Date) input[key] = value.toISOString();
 	}
 	return input;
@@ -688,13 +611,13 @@ function buildDomainEventChannelName(input, id) {
 	return input(id);
 }
 //#endregion
-//#region src/domain-event/redis/module.ts
-var DomainEventRedisPublisher = class {
+//#region src/domain-event/handlers/redis/module.ts
+var DomainEventRedisHandler = class {
 	driver;
 	constructor(input) {
 		this.driver = createRedisClient(input);
 	}
-	async publish(ctx) {
+	async handle(ctx) {
 		const data = JSON.stringify(transformDomainEventData(ctx.content));
 		const pipeline = this.driver.pipeline();
 		for (let i = 0; i < ctx.destinations.length; i++) {
@@ -711,14 +634,14 @@ var DomainEventRedisPublisher = class {
 	}
 };
 //#endregion
-//#region src/domain-event/socket/module.ts
-var DomainEventSocketPublisher = class {
+//#region src/domain-event/handlers/socket/module.ts
+var DomainEventSocketHandler = class {
 	driver;
 	constructor(input) {
 		const client = createRedisClient(input);
 		this.driver = new Emitter(client);
 	}
-	async publish(ctx) {
+	async handle(ctx) {
 		ctx.content = transformDomainEventData(ctx.content);
 		for (let i = 0; i < ctx.destinations.length; i++) {
 			const destination = ctx.destinations[i];
@@ -745,11 +668,77 @@ var DomainEventSocketPublisher = class {
 	}
 };
 //#endregion
+//#region src/domain-event/module.ts
+var DomainEventPublisher = class {
+	handlers;
+	logger;
+	constructor(ctx = {}) {
+		this.handlers = /* @__PURE__ */ new Set();
+		this.logger = ctx.logger;
+	}
+	register(handler) {
+		this.handlers.add(handler);
+	}
+	async dispose() {
+		for (const handler of this.handlers) if (handler.dispose) await handler.dispose();
+		this.handlers.clear();
+	}
+	async safePublish(ctx) {
+		try {
+			await this.publish(ctx);
+		} catch (e) {
+			if (this.logger) {
+				this.logger.error(`Publishing event ${buildEventFullName(ctx.content.type, ctx.content.event)} failed.`);
+				this.logger.error(e);
+			}
+		}
+	}
+	async publish(ctx) {
+		if (this.handlers.size === 0) return;
+		if (this.logger) this.logger.debug(`Publishing event ${buildEventFullName(ctx.content.type, ctx.content.event)}...`);
+		const handlers = this.handlers.values();
+		while (true) {
+			const it = handlers.next();
+			if (it.done) return;
+			await it.value.handle(ctx);
+		}
+	}
+};
+//#endregion
+//#region src/logger/module.ts
+function createNoopLogger() {
+	return createLogger$1({ silent: true });
+}
+function createLogger(context) {
+	let items;
+	const cwd = context.directory || process.cwd();
+	if (context.env === "production") items = [
+		new transports.Console({ level: "info" }),
+		new transports.File({
+			filename: path.join(cwd, "http.log"),
+			level: "http",
+			maxsize: 10 * 1024 * 1024,
+			maxFiles: 5
+		}),
+		new transports.File({
+			filename: path.join(cwd, "error.log"),
+			level: "warn",
+			maxsize: 10 * 1024 * 1024,
+			maxFiles: 5
+		})
+	];
+	else items = [new transports.Console({ level: "debug" })];
+	return createLogger$1({
+		format: format.combine(format.errors({ stack: true }), format.timestamp(), format.colorize(), format.simple()),
+		transports: items
+	});
+}
+//#endregion
 //#region src/utils/has-property.ts
 function hasOwnProperty(obj, prop) {
 	return Object.prototype.hasOwnProperty.call(obj, prop);
 }
 //#endregion
-export { AbstractEntityService, AsymmetricKey, BaseKey, CryptoAsymmetricAlgorithm, DomainEventPublisher, DomainEventRedisPublisher, DomainEventSocketPublisher, Logger, MemoryCache, RedisCache, RedisClient, RedisJsonAdapter, RedisWatcher, SymmetricAlgorithm, SymmetricKey, VaultClient, buildCacheKey, buildRedisKeyPath, compare, createAsymmetricKeyPair, createLogger, createNoopLogger, createRedisClient, createSymmetricKey, createVaultClient, decodePemToPKCS8, decodePemToSpki, encodePKCS8ToPEM, encodeSPKIToPem, escapeRedisKey, extractTokenHeader, extractTokenPayload, getKeyUsagesForAsymmetricAlgorithm, getKeyUsagesForSymmetricAlgorithm, hasOwnProperty, hash, isAsymmetricAlgorithm, isLoggerUsable, isRedisClient, isSymmetricAlgorithm, isVaultClientUsable, normalizeAsymmetricKeyImportOptions, normalizeAsymmetricKeyPairCreateOptions, parseRedisKeyPath, setLogger, setLoggerFactory, setVaultFactory, signToken, useLogger, useVaultClient, verifyToken };
+export { AbstractEntityService, AsymmetricKey, BaseKey, CryptoAsymmetricAlgorithm, DomainEventPublisher, DomainEventRedisHandler, DomainEventSocketHandler, MemoryCache, RedisCache, RedisClient, RedisJsonAdapter, RedisWatcher, SymmetricAlgorithm, SymmetricKey, buildCacheKey, buildRedisKeyPath, compare, createAsymmetricKeyPair, createLogger, createNoopLogger, createRedisClient, createSymmetricKey, decodePemToPKCS8, decodePemToSpki, encodePKCS8ToPEM, encodeSPKIToPem, escapeRedisKey, extractTokenHeader, extractTokenPayload, getKeyUsagesForAsymmetricAlgorithm, getKeyUsagesForSymmetricAlgorithm, hasOwnProperty, hash, isAsymmetricAlgorithm, isRedisClient, isSymmetricAlgorithm, normalizeAsymmetricKeyImportOptions, normalizeAsymmetricKeyPairCreateOptions, parseRedisKeyPath, signToken, verifyToken };
 
 //# sourceMappingURL=index.mjs.map