@hot-updater/plugin-core 0.21.11 → 0.21.13

package/dist/createDatabasePlugin.cjs

@@ -4,93 +4,89 @@ es_toolkit = require_rolldown_runtime.__toESM(es_toolkit);
 
 //#region src/createDatabasePlugin.ts
 /**
-* Creates a database plugin with the given implementation.
+* Creates a database plugin with lazy initialization and automatic hook execution.
+*
+* This factory function abstracts the double currying pattern used by all database plugins,
+* ensuring consistent lazy initialization behavior across different database providers.
+* Hooks are automatically executed at appropriate times without requiring manual invocation.
+*
+* @param options - Configuration options for the database plugin
+* @returns A double-curried function that lazily initializes the database plugin
 *
 * @example
-* ```ts
-* const myDatabasePlugin = createDatabasePlugin("myDatabase", {
-*   getContext: () => ({
-*     // Your database client or connection
-*     dbClient: createDbClient()
-*   }),
-*   async getBundleById(context, bundleId) {
-*     // Implementation to get a bundle by ID using context.dbClient
-*     return bundle;
-*   },
-*   async getBundles(context, options) {
-*     // Implementation to get bundles with options using context.dbClient
-*     return bundles;
-*   },
-*   async getChannels(context) {
-*     // Implementation to get available channels using context.dbClient
-*     return channels;
-*   },
-*   async commitBundle(context, { changedSets }) {
-*     // Implementation to commit changed bundles using context.dbClient
+* ```typescript
+* export const postgres = createDatabasePlugin<PostgresConfig>({
+*   name: "postgres",
+*   factory: (config) => {
+*     const db = new Kysely(config);
+*     return {
+*       async getBundleById(bundleId) { ... },
+*       async getBundles(options) { ... },
+*       async getChannels() { ... },
+*       async commitBundle({ changedSets }) { ... }
+*     };
 *   }
 * });
 * ```
-*
-* @param name - The name of the database plugin
-* @param abstractPlugin - A plugin implementation with context support
-* @param hooks - Optional hooks for plugin lifecycle events
-* @returns A function that creates a database plugin instance
 */
-function createDatabasePlugin(name, abstractPlugin, hooks) {
-	const changedMap = /* @__PURE__ */ new Map();
-	const markChanged = (operation, data) => {
-		changedMap.set(data.id, {
-			operation,
-			data
-		});
-	};
-	const memoizedContext = (0, es_toolkit.memoize)(abstractPlugin?.getContext ?? (() => {}));
-	return () => ({
-		name,
-		async getBundleById(bundleId) {
-			const context = memoizedContext();
-			return abstractPlugin.getBundleById(context, bundleId);
-		},
-		async getBundles(options) {
-			const context = memoizedContext();
-			return abstractPlugin.getBundles(context, options);
-		},
-		async getChannels() {
-			const context = memoizedContext();
-			return abstractPlugin.getChannels(context);
-		},
-		async commitBundle() {
-			if (!abstractPlugin.commitBundle) throw new Error("commitBundle is not implemented");
-			const context = memoizedContext();
-			await abstractPlugin.commitBundle(context, { changedSets: Array.from(changedMap.values()) });
-			changedMap.clear();
-			hooks?.onDatabaseUpdated?.();
-		},
-		async updateBundle(targetBundleId, newBundle) {
-			const pendingChange = changedMap.get(targetBundleId);
-			if (pendingChange) {
-				const updatedData = (0, es_toolkit.merge)(pendingChange.data, newBundle);
-				changedMap.set(targetBundleId, {
-					operation: pendingChange.operation,
-					data: updatedData
+function createDatabasePlugin(options) {
+	return (config, hooks) => {
+		return () => {
+			let cachedMethods = null;
+			const getMethods = () => {
+				if (!cachedMethods) cachedMethods = options.factory(config);
+				return cachedMethods;
+			};
+			const changedMap = /* @__PURE__ */ new Map();
+			const markChanged = (operation, data) => {
+				changedMap.set(data.id, {
+					operation,
+					data
 				});
-				return;
-			}
-			const currentBundle = await this.getBundleById(targetBundleId);
-			if (!currentBundle) throw new Error("targetBundleId not found");
-			markChanged("update", (0, es_toolkit.merge)(currentBundle, newBundle));
-		},
-		async appendBundle(inputBundle) {
-			markChanged("insert", inputBundle);
-		},
-		onUnmount: abstractPlugin.onUnmount ? async () => {
-			const context = memoizedContext();
-			await abstractPlugin.onUnmount?.(context);
-		} : void 0,
-		async deleteBundle(deleteBundle) {
-			markChanged("delete", deleteBundle);
-		}
-	});
+			};
+			return {
+				name: options.name,
+				async getBundleById(bundleId) {
+					return getMethods().getBundleById(bundleId);
+				},
+				async getBundles(options$1) {
+					return getMethods().getBundles(options$1);
+				},
+				async getChannels() {
+					return getMethods().getChannels();
+				},
+				async onUnmount() {
+					const methods = getMethods();
+					if (methods.onUnmount) return methods.onUnmount();
+				},
+				async commitBundle() {
+					await getMethods().commitBundle({ changedSets: Array.from(changedMap.values()) });
+					await hooks?.onDatabaseUpdated?.();
+					changedMap.clear();
+				},
+				async updateBundle(targetBundleId, newBundle) {
+					const pendingChange = changedMap.get(targetBundleId);
+					if (pendingChange) {
+						const updatedData = (0, es_toolkit.merge)(pendingChange.data, newBundle);
+						changedMap.set(targetBundleId, {
+							operation: pendingChange.operation,
+							data: updatedData
+						});
+						return;
+					}
+					const currentBundle = await getMethods().getBundleById(targetBundleId);
+					if (!currentBundle) throw new Error("targetBundleId not found");
+					markChanged("update", (0, es_toolkit.merge)(currentBundle, newBundle));
+				},
+				async appendBundle(inputBundle) {
+					markChanged("insert", inputBundle);
+				},
+				async deleteBundle(deleteBundle) {
+					markChanged("delete", deleteBundle);
+				}
+			};
+		};
+	};
 }
 
 //#endregion

package/dist/createDatabasePlugin.d.cts

@@ -2,10 +2,9 @@ import { DatabasePlugin, DatabasePluginHooks, PaginationInfo } from "./types/ind
 import { Bundle } from "@hot-updater/core";
 
 //#region src/createDatabasePlugin.d.ts
-interface AbstractDatabasePlugin<TContext = object> {
-  getContext?: () => TContext;
-  getBundleById: (context: TContext, bundleId: string) => Promise<Bundle | null>;
-  getBundles: (context: TContext, options: {
+interface AbstractDatabasePlugin {
+  getBundleById: (bundleId: string) => Promise<Bundle | null>;
+  getBundles: (options: {
     where?: {
       channel?: string;
       platform?: string;
@@ -16,11 +15,9 @@ interface AbstractDatabasePlugin<TContext = object> {
     data: Bundle[];
     pagination: PaginationInfo;
   }>;
-  getChannels: (context: TContext) => Promise<string[]>;
-  onUnmount?: (context: TContext) => void;
-  commitBundle: (context: TContext, {
-    changedSets
-  }: {
+  getChannels: () => Promise<string[]>;
+  onUnmount?: () => Promise<void>;
+  commitBundle: (params: {
     changedSets: {
       operation: "insert" | "update" | "delete";
       data: Bundle;
@@ -28,38 +25,52 @@ interface AbstractDatabasePlugin<TContext = object> {
   }) => Promise<void>;
 }
 /**
- * Creates a database plugin with the given implementation.
+ * Database plugin methods without name
+ */
+type DatabasePluginMethods = Omit<AbstractDatabasePlugin, never>;
+/**
+ * Factory function that creates database plugin methods
+ */
+type DatabasePluginFactory<TConfig> = (config: TConfig) => DatabasePluginMethods;
+/**
+ * Configuration options for creating a database plugin
+ */
+interface CreateDatabasePluginOptions<TConfig> {
+  /**
+   * The name of the database plugin (e.g., "postgres", "d1Database")
+   */
+  name: string;
+  /**
+   * Function that creates the database plugin methods
+   */
+  factory: DatabasePluginFactory<TConfig>;
+}
+/**
+ * Creates a database plugin with lazy initialization and automatic hook execution.
+ *
+ * This factory function abstracts the double currying pattern used by all database plugins,
+ * ensuring consistent lazy initialization behavior across different database providers.
+ * Hooks are automatically executed at appropriate times without requiring manual invocation.
+ *
+ * @param options - Configuration options for the database plugin
+ * @returns A double-curried function that lazily initializes the database plugin
  *
  * @example
- * ```ts
- * const myDatabasePlugin = createDatabasePlugin("myDatabase", {
- *   getContext: () => ({
- *     // Your database client or connection
- *     dbClient: createDbClient()
- *   }),
- *   async getBundleById(context, bundleId) {
- *     // Implementation to get a bundle by ID using context.dbClient
- *     return bundle;
- *   },
- *   async getBundles(context, options) {
- *     // Implementation to get bundles with options using context.dbClient
- *     return bundles;
- *   },
- *   async getChannels(context) {
- *     // Implementation to get available channels using context.dbClient
- *     return channels;
- *   },
- *   async commitBundle(context, { changedSets }) {
- *     // Implementation to commit changed bundles using context.dbClient
+ * ```typescript
+ * export const postgres = createDatabasePlugin<PostgresConfig>({
+ *   name: "postgres",
+ *   factory: (config) => {
+ *     const db = new Kysely(config);
+ *     return {
+ *       async getBundleById(bundleId) { ... },
+ *       async getBundles(options) { ... },
+ *       async getChannels() { ... },
+ *       async commitBundle({ changedSets }) { ... }
+ *     };
  *   }
  * });
  * ```
- *
- * @param name - The name of the database plugin
- * @param abstractPlugin - A plugin implementation with context support
- * @param hooks - Optional hooks for plugin lifecycle events
- * @returns A function that creates a database plugin instance
  */
-declare function createDatabasePlugin<TContext = object>(name: string, abstractPlugin: AbstractDatabasePlugin<TContext>, hooks?: DatabasePluginHooks): () => DatabasePlugin;
+declare function createDatabasePlugin<TConfig>(options: CreateDatabasePluginOptions<TConfig>): (config: TConfig, hooks?: DatabasePluginHooks) => (() => DatabasePlugin);
 //#endregion
-export { AbstractDatabasePlugin, createDatabasePlugin };
+export { AbstractDatabasePlugin, CreateDatabasePluginOptions, createDatabasePlugin };

package/dist/createDatabasePlugin.d.ts

@@ -2,10 +2,9 @@ import { DatabasePlugin, DatabasePluginHooks, PaginationInfo } from "./types/ind
 import { Bundle } from "@hot-updater/core";
 
 //#region src/createDatabasePlugin.d.ts
-interface AbstractDatabasePlugin<TContext = object> {
-  getContext?: () => TContext;
-  getBundleById: (context: TContext, bundleId: string) => Promise<Bundle | null>;
-  getBundles: (context: TContext, options: {
+interface AbstractDatabasePlugin {
+  getBundleById: (bundleId: string) => Promise<Bundle | null>;
+  getBundles: (options: {
     where?: {
       channel?: string;
       platform?: string;
@@ -16,11 +15,9 @@ interface AbstractDatabasePlugin<TContext = object> {
     data: Bundle[];
     pagination: PaginationInfo;
   }>;
-  getChannels: (context: TContext) => Promise<string[]>;
-  onUnmount?: (context: TContext) => void;
-  commitBundle: (context: TContext, {
-    changedSets
-  }: {
+  getChannels: () => Promise<string[]>;
+  onUnmount?: () => Promise<void>;
+  commitBundle: (params: {
     changedSets: {
       operation: "insert" | "update" | "delete";
       data: Bundle;
@@ -28,38 +25,52 @@ interface AbstractDatabasePlugin<TContext = object> {
   }) => Promise<void>;
 }
 /**
- * Creates a database plugin with the given implementation.
+ * Database plugin methods without name
+ */
+type DatabasePluginMethods = Omit<AbstractDatabasePlugin, never>;
+/**
+ * Factory function that creates database plugin methods
+ */
+type DatabasePluginFactory<TConfig> = (config: TConfig) => DatabasePluginMethods;
+/**
+ * Configuration options for creating a database plugin
+ */
+interface CreateDatabasePluginOptions<TConfig> {
+  /**
+   * The name of the database plugin (e.g., "postgres", "d1Database")
+   */
+  name: string;
+  /**
+   * Function that creates the database plugin methods
+   */
+  factory: DatabasePluginFactory<TConfig>;
+}
+/**
+ * Creates a database plugin with lazy initialization and automatic hook execution.
+ *
+ * This factory function abstracts the double currying pattern used by all database plugins,
+ * ensuring consistent lazy initialization behavior across different database providers.
+ * Hooks are automatically executed at appropriate times without requiring manual invocation.
+ *
+ * @param options - Configuration options for the database plugin
+ * @returns A double-curried function that lazily initializes the database plugin
  *
  * @example
- * ```ts
- * const myDatabasePlugin = createDatabasePlugin("myDatabase", {
- *   getContext: () => ({
- *     // Your database client or connection
- *     dbClient: createDbClient()
- *   }),
- *   async getBundleById(context, bundleId) {
- *     // Implementation to get a bundle by ID using context.dbClient
- *     return bundle;
- *   },
- *   async getBundles(context, options) {
- *     // Implementation to get bundles with options using context.dbClient
- *     return bundles;
- *   },
- *   async getChannels(context) {
- *     // Implementation to get available channels using context.dbClient
- *     return channels;
- *   },
- *   async commitBundle(context, { changedSets }) {
- *     // Implementation to commit changed bundles using context.dbClient
+ * ```typescript
+ * export const postgres = createDatabasePlugin<PostgresConfig>({
+ *   name: "postgres",
+ *   factory: (config) => {
+ *     const db = new Kysely(config);
+ *     return {
+ *       async getBundleById(bundleId) { ... },
+ *       async getBundles(options) { ... },
+ *       async getChannels() { ... },
+ *       async commitBundle({ changedSets }) { ... }
+ *     };
  *   }
  * });
  * ```
- *
- * @param name - The name of the database plugin
- * @param abstractPlugin - A plugin implementation with context support
- * @param hooks - Optional hooks for plugin lifecycle events
- * @returns A function that creates a database plugin instance
  */
-declare function createDatabasePlugin<TContext = object>(name: string, abstractPlugin: AbstractDatabasePlugin<TContext>, hooks?: DatabasePluginHooks): () => DatabasePlugin;
+declare function createDatabasePlugin<TConfig>(options: CreateDatabasePluginOptions<TConfig>): (config: TConfig, hooks?: DatabasePluginHooks) => (() => DatabasePlugin);
 //#endregion
-export { AbstractDatabasePlugin, createDatabasePlugin };
+export { AbstractDatabasePlugin, CreateDatabasePluginOptions, createDatabasePlugin };

package/dist/createDatabasePlugin.js

@@ -1,94 +1,90 @@
-import { memoize, merge } from "es-toolkit";
+import { merge } from "es-toolkit";
 
 //#region src/createDatabasePlugin.ts
 /**
-* Creates a database plugin with the given implementation.
+* Creates a database plugin with lazy initialization and automatic hook execution.
+*
+* This factory function abstracts the double currying pattern used by all database plugins,
+* ensuring consistent lazy initialization behavior across different database providers.
+* Hooks are automatically executed at appropriate times without requiring manual invocation.
+*
+* @param options - Configuration options for the database plugin
+* @returns A double-curried function that lazily initializes the database plugin
 *
 * @example
-* ```ts
-* const myDatabasePlugin = createDatabasePlugin("myDatabase", {
-*   getContext: () => ({
-*     // Your database client or connection
-*     dbClient: createDbClient()
-*   }),
-*   async getBundleById(context, bundleId) {
-*     // Implementation to get a bundle by ID using context.dbClient
-*     return bundle;
-*   },
-*   async getBundles(context, options) {
-*     // Implementation to get bundles with options using context.dbClient
-*     return bundles;
-*   },
-*   async getChannels(context) {
-*     // Implementation to get available channels using context.dbClient
-*     return channels;
-*   },
-*   async commitBundle(context, { changedSets }) {
-*     // Implementation to commit changed bundles using context.dbClient
+* ```typescript
+* export const postgres = createDatabasePlugin<PostgresConfig>({
+*   name: "postgres",
+*   factory: (config) => {
+*     const db = new Kysely(config);
+*     return {
+*       async getBundleById(bundleId) { ... },
+*       async getBundles(options) { ... },
+*       async getChannels() { ... },
+*       async commitBundle({ changedSets }) { ... }
+*     };
 *   }
 * });
 * ```
-*
-* @param name - The name of the database plugin
-* @param abstractPlugin - A plugin implementation with context support
-* @param hooks - Optional hooks for plugin lifecycle events
-* @returns A function that creates a database plugin instance
 */
-function createDatabasePlugin(name, abstractPlugin, hooks) {
-	const changedMap = /* @__PURE__ */ new Map();
-	const markChanged = (operation, data) => {
-		changedMap.set(data.id, {
-			operation,
-			data
-		});
-	};
-	const memoizedContext = memoize(abstractPlugin?.getContext ?? (() => {}));
-	return () => ({
-		name,
-		async getBundleById(bundleId) {
-			const context = memoizedContext();
-			return abstractPlugin.getBundleById(context, bundleId);
-		},
-		async getBundles(options) {
-			const context = memoizedContext();
-			return abstractPlugin.getBundles(context, options);
-		},
-		async getChannels() {
-			const context = memoizedContext();
-			return abstractPlugin.getChannels(context);
-		},
-		async commitBundle() {
-			if (!abstractPlugin.commitBundle) throw new Error("commitBundle is not implemented");
-			const context = memoizedContext();
-			await abstractPlugin.commitBundle(context, { changedSets: Array.from(changedMap.values()) });
-			changedMap.clear();
-			hooks?.onDatabaseUpdated?.();
-		},
-		async updateBundle(targetBundleId, newBundle) {
-			const pendingChange = changedMap.get(targetBundleId);
-			if (pendingChange) {
-				const updatedData = merge(pendingChange.data, newBundle);
-				changedMap.set(targetBundleId, {
-					operation: pendingChange.operation,
-					data: updatedData
+function createDatabasePlugin(options) {
+	return (config, hooks) => {
+		return () => {
+			let cachedMethods = null;
+			const getMethods = () => {
+				if (!cachedMethods) cachedMethods = options.factory(config);
+				return cachedMethods;
+			};
+			const changedMap = /* @__PURE__ */ new Map();
+			const markChanged = (operation, data) => {
+				changedMap.set(data.id, {
+					operation,
+					data
 				});
-				return;
-			}
-			const currentBundle = await this.getBundleById(targetBundleId);
-			if (!currentBundle) throw new Error("targetBundleId not found");
-			markChanged("update", merge(currentBundle, newBundle));
-		},
-		async appendBundle(inputBundle) {
-			markChanged("insert", inputBundle);
-		},
-		onUnmount: abstractPlugin.onUnmount ? async () => {
-			const context = memoizedContext();
-			await abstractPlugin.onUnmount?.(context);
-		} : void 0,
-		async deleteBundle(deleteBundle) {
-			markChanged("delete", deleteBundle);
-		}
-	});
+			};
+			return {
+				name: options.name,
+				async getBundleById(bundleId) {
+					return getMethods().getBundleById(bundleId);
+				},
+				async getBundles(options$1) {
+					return getMethods().getBundles(options$1);
+				},
+				async getChannels() {
+					return getMethods().getChannels();
+				},
+				async onUnmount() {
+					const methods = getMethods();
+					if (methods.onUnmount) return methods.onUnmount();
+				},
+				async commitBundle() {
+					await getMethods().commitBundle({ changedSets: Array.from(changedMap.values()) });
+					await hooks?.onDatabaseUpdated?.();
+					changedMap.clear();
+				},
+				async updateBundle(targetBundleId, newBundle) {
+					const pendingChange = changedMap.get(targetBundleId);
+					if (pendingChange) {
+						const updatedData = merge(pendingChange.data, newBundle);
+						changedMap.set(targetBundleId, {
+							operation: pendingChange.operation,
+							data: updatedData
+						});
+						return;
+					}
+					const currentBundle = await getMethods().getBundleById(targetBundleId);
+					if (!currentBundle) throw new Error("targetBundleId not found");
+					markChanged("update", merge(currentBundle, newBundle));
+				},
+				async appendBundle(inputBundle) {
+					markChanged("insert", inputBundle);
+				},
+				async deleteBundle(deleteBundle) {
+					markChanged("delete", deleteBundle);
+				}
+			};
+		};
+	};
 }
 
 //#endregion

package/dist/createStoragePlugin.cjs

@@ -0,0 +1,57 @@
+
+//#region src/createStoragePlugin.ts
+/**
+* Creates a storage plugin with lazy initialization and automatic hook execution.
+*
+* This factory function abstracts the double currying pattern used by all storage plugins,
+* ensuring consistent lazy initialization behavior across different storage providers.
+* Hooks are automatically executed at appropriate times without requiring manual invocation.
+*
+* @param options - Configuration options for the storage plugin
+* @returns A double-curried function that lazily initializes the storage plugin
+*
+* @example
+* ```typescript
+* export const s3Storage = createStoragePlugin<S3StorageConfig>({
+*   name: "s3Storage",
+*   supportedProtocol: "s3",
+*   factory: (config) => {
+*     const client = new S3Client(config);
+*     return {
+*       async upload(key, filePath) { ... },
+*       async delete(storageUri) { ... },
+*       async getDownloadUrl(storageUri) { ... }
+*     };
+*   }
+* });
+* ```
+*/
+const createStoragePlugin = (options) => {
+	return (config, hooks) => {
+		return () => {
+			let cachedMethods = null;
+			const getMethods = () => {
+				if (!cachedMethods) cachedMethods = options.factory(config);
+				return cachedMethods;
+			};
+			return {
+				name: options.name,
+				supportedProtocol: options.supportedProtocol,
+				async upload(key, filePath) {
+					const result = await getMethods().upload(key, filePath);
+					await hooks?.onStorageUploaded?.();
+					return result;
+				},
+				async delete(storageUri) {
+					return getMethods().delete(storageUri);
+				},
+				async getDownloadUrl(storageUri) {
+					return getMethods().getDownloadUrl(storageUri);
+				}
+			};
+		};
+	};
+};
+
+//#endregion
+exports.createStoragePlugin = createStoragePlugin;