@asterflow/plugin 1.0.1 → 1.0.3

package/dist/cjs/index.cjs

@@ -1,88 +1,121 @@
 "use strict";
 var r = Object.defineProperty;
-var f = Object.getOwnPropertyDescriptor;
-var u = Object.getOwnPropertyNames;
-var d = Object.prototype.hasOwnProperty;
-var g = (t, e) => {
-  for (var o in e)
-    r(t, o, { get: e[o], enumerable: !0 });
-}, C = (t, e, o, n) => {
+var h = Object.getOwnPropertyDescriptor;
+var d = Object.getOwnPropertyNames;
+var c = Object.prototype.hasOwnProperty;
+var f = (t, e) => {
+  for (var n in e)
+    r(t, n, { get: e[n], enumerable: !0 });
+}, u = (t, e, n, s) => {
   if (e && typeof e == "object" || typeof e == "function")
-    for (let s of u(e))
-      !d.call(t, s) && s !== o && r(t, s, { get: () => e[s], enumerable: !(n = f(e, s)) || n.enumerable });
+    for (let o of d(e))
+      !c.call(t, o) && o !== n && r(t, o, { get: () => e[o], enumerable: !(s = h(e, o)) || s.enumerable });
   return t;
 };
-var x = (t) => C(r({}, "__esModule", { value: !0 }), t);
+var g = (t) => u(r({}, "__esModule", { value: !0 }), t);
 // packages/plugin/src/index.ts
-var y = {};
-g(y, {
+var C = {};
+f(C, {
   Plugin: () => a
 });
-module.exports = x(y);
+module.exports = g(C);
 // packages/plugin/src/controllers/Plugin.ts
 var a = class t {
   name;
   resolvers;
   defaultConfig;
   hooks;
-  constructor(e, o, n, s) {
-    this.name = e, this.resolvers = o, this.hooks = n, this.defaultConfig = s;
+  instance;
+  _extensionFn;
+  constructor(e, n, s, o, i) {
+    this.name = e, this.resolvers = n, this.hooks = s, this.defaultConfig = o, this._extensionFn = i;
   }
-  withConfig(e) {
+  config(e) {
     return new t(
       this.name,
       this.resolvers,
       this.hooks,
-      e
+      e,
+      this._extensionFn
     );
   }
-  decorate(e, o) {
-    let n = (s, i) => ({
+  defineInstance(e) {
+    return this.instance = e, this;
+  }
+  decorate(e, n) {
+    let s = async (o, i) => ({
       ...i,
-      [e]: o
+      [e]: n
     });
     return new t(
       this.name,
-      [...this.resolvers, n],
+      [...this.resolvers, s],
       this.hooks,
-      this.defaultConfig
+      this.defaultConfig,
+      this._extensionFn
     );
   }
-  derive(e, o) {
-    let n = (s, i) => {
-      let l = { ...i, ...s }, h = o(l);
+  derive(e, n) {
+    let s = async (o, i) => {
+      let l = { ...i, ...o }, x = await n(l);
       return {
         ...i,
-        [e]: h
+        [e]: x
       };
     };
     return new t(
       this.name,
-      [...this.resolvers, n],
+      [...this.resolvers, s],
       this.hooks,
-      this.defaultConfig
+      this.defaultConfig,
+      this._extensionFn
     );
   }
-  on(e, o) {
-    return this.hooks[e] || (this.hooks[e] = []), this.hooks[e].push(o), new t(
+  on(e, n) {
+    let s = this.hooks[e] || [], o = {
+      ...this.hooks,
+      [e]: [...s, n]
+    };
+    return new t(
+      this.name,
+      this.resolvers,
+      o,
+      this.defaultConfig,
+      this._extensionFn
+    );
+  }
+  extends(e) {
+    return new t(
       this.name,
       this.resolvers,
       this.hooks,
-      this.defaultConfig
+      this.defaultConfig,
+      (n, s) => ({ ...this._extensionFn ? this._extensionFn(n, s) : {}, ...e(n, s) })
     );
   }
   _build(e) {
-    let o = { ...this.defaultConfig, ...e }, n = {};
-    for (let s of this.resolvers)
-      n = s(o, n);
+    let n = { ...this.defaultConfig, ...e };
     return {
       name: this.name,
-      context: n,
-      hooks: this.hooks
+      context: { ...n },
+      hooks: this.hooks,
+      _extensionFn: this._extensionFn,
+      resolvers: this.resolvers
     };
   }
   static create(e) {
-    return new t(e.name, [], {}, {});
+    return new t(e.name, [], {}, {}, void 0);
+  }
+  static instance() {
+    return {
+      create: (e) => new t(
+        e.name,
+        [],
+        {},
+        {},
+        void 0
+      )
+    };
   }
 };
 0 && (module.exports = {

package/dist/mjs/index.js

@@ -4,32 +4,39 @@ var r = class s {
   resolvers;
   defaultConfig;
   hooks;
-  constructor(e, o, t, n) {
-    this.name = e, this.resolvers = o, this.hooks = t, this.defaultConfig = n;
+  instance;
+  _extensionFn;
+  constructor(e, n, t, o, i) {
+    this.name = e, this.resolvers = n, this.hooks = t, this.defaultConfig = o, this._extensionFn = i;
   }
-  withConfig(e) {
+  config(e) {
     return new s(
       this.name,
       this.resolvers,
       this.hooks,
-      e
+      e,
+      this._extensionFn
     );
   }
-  decorate(e, o) {
-    let t = (n, i) => ({
+  defineInstance(e) {
+    return this.instance = e, this;
+  }
+  decorate(e, n) {
+    let t = async (o, i) => ({
       ...i,
-      [e]: o
+      [e]: n
     });
     return new s(
       this.name,
       [...this.resolvers, t],
       this.hooks,
-      this.defaultConfig
+      this.defaultConfig,
+      this._extensionFn
     );
   }
-  derive(e, o) {
-    let t = (n, i) => {
-      let a = { ...i, ...n }, l = o(a);
+  derive(e, n) {
+    let t = async (o, i) => {
+      let a = { ...i, ...o }, l = await n(a);
       return {
         ...i,
         [e]: l
@@ -39,29 +46,55 @@ var r = class s {
       this.name,
       [...this.resolvers, t],
       this.hooks,
-      this.defaultConfig
+      this.defaultConfig,
+      this._extensionFn
     );
   }
-  on(e, o) {
-    return this.hooks[e] || (this.hooks[e] = []), this.hooks[e].push(o), new s(
+  on(e, n) {
+    let t = this.hooks[e] || [], o = {
+      ...this.hooks,
+      [e]: [...t, n]
+    };
+    return new s(
+      this.name,
+      this.resolvers,
+      o,
+      this.defaultConfig,
+      this._extensionFn
+    );
+  }
+  extends(e) {
+    return new s(
       this.name,
       this.resolvers,
       this.hooks,
-      this.defaultConfig
+      this.defaultConfig,
+      (n, t) => ({ ...this._extensionFn ? this._extensionFn(n, t) : {}, ...e(n, t) })
     );
   }
   _build(e) {
-    let o = { ...this.defaultConfig, ...e }, t = {};
-    for (let n of this.resolvers)
-      t = n(o, t);
+    let n = { ...this.defaultConfig, ...e };
     return {
       name: this.name,
-      context: t,
-      hooks: this.hooks
+      context: { ...n },
+      hooks: this.hooks,
+      _extensionFn: this._extensionFn,
+      resolvers: this.resolvers
     };
   }
   static create(e) {
-    return new s(e.name, [], {}, {});
+    return new s(e.name, [], {}, {}, void 0);
+  }
+  static instance() {
+    return {
+      create: (e) => new s(
+        e.name,
+        [],
+        {},
+        {},
+        void 0
+      )
+    };
   }
 };
 export {

package/dist/types/controllers/Plugin.d.ts

@@ -1,28 +1,36 @@
-import type { AnyPluginHooks } from '../types/plugin';
+import type { AnyAsterflow, ExtendedAsterflow } from '@asterflow/core';
+import type { PluginHooks, Resolver } from '../types/plugin';
 /**
  * A factory for creating plugins that can be configured and attached to AsterFlow.
  * Plugins are defined with a series of resolvers (`decorate`, `derive`) and lifecycle
  * hooks (`on`) that build up its context and runtime behavior.
  */
-export declare class Plugin<Path extends string, Config extends Record<string, any> = {}, Context extends Record<string, any> = {}, THooks extends AnyPluginHooks = {}> {
+export declare class Plugin<Path extends string, Instance extends AnyAsterflow, Config extends Record<string, any> = {}, Context extends Record<string, any> = {}, Hooks extends PluginHooks<any, Context[], any> = {}, Extension extends Record<string, any> = {}> {
     readonly name: Path;
     private readonly resolvers;
     readonly defaultConfig: Partial<Config>;
-    readonly hooks: THooks;
+    readonly hooks: Hooks;
+    instance: Instance;
+    private readonly _extensionFn?;
     private constructor();
     /**
      * Defines the shape of the configuration and its default values for this plugin.
      */
-    withConfig<C extends Record<string, any>>(defaultConfig: C): Plugin<Path, C, Context, THooks>;
+    config<C extends Record<string, any>>(defaultConfig: C): Plugin<Path, Instance, C, Context, Hooks, Extension>;
+    /**
+     * O `defineInstance` agora é mais simples. Ele não precisa mais re-tipar
+     * a classe inteira. Ele só serve para passar o `this` para o `_build`.
+     */
+    defineInstance<Instanced extends AnyAsterflow>(instance: Instanced): this;
     /**
      * Adds a new static value to the plugin's context (decoration).
      */
-    decorate<Key extends string, Value>(key: Key, value: Value): Plugin<Path, Config, Context & { [K in Key]: Value; }, THooks>;
+    decorate<Key extends string, Value>(key: Key, value: Value): Plugin<Path, Instance, Config, Context & { [K in Key]: Value; }, Hooks, Extension>;
     /**
      * Adds a new property to the context that is derived from the configuration and the existing context.
      * The resolver function is executed lazily when the plugin is registered via `app.use()`.
      */
-    derive<Key extends string, Value>(key: Key, resolverFn: (context: Context & Config) => Value): Plugin<Path, Config, Context & { [K in Key]: Value; }, THooks>;
+    derive<Key extends string, Value>(key: Key, resolverFn: (context: Context & Config) => Value | Promise<Value>): Plugin<Path, Instance, Config, Context & { [K in Key]: Awaited<Value>; }, Hooks, Extension>;
     /**
      * Registers a handler for a specific lifecycle event.
      * Adding a hook makes the plugin "runtime-aware". AsterFlow can optimize by only
@@ -30,25 +38,35 @@ export declare class Plugin<Path extends string, Config extends Record<string, a
      *
      * @example
      * const routingPlugin = Plugin.create({ name: 'dynamic-routes' })
-     * .on('beforeInitialize', (app, context) => {
-     * // `app` is the AsterFlow instance
-     * const dynamicRouter = createDynamicRouter();
-     * app.controller(dynamicRouter);
-     * });
+     *   .on('beforeInitialize', (app, context) => { })
+     *   .on('beforeInitialize', (app, context) => { });
      */
-    on<Event extends keyof AnyPluginHooks, Handler extends NonNullable<AnyPluginHooks[Event]> extends (infer F)[] ? F : never>(event: Event, handler: Handler): Plugin<Path, Config, Context, THooks>;
+    on<Event extends keyof PluginHooks<ExtendedAsterflow<Instance>, Context & Config, Extension>, Handler extends NonNullable<PluginHooks<ExtendedAsterflow<Instance>, Context & Config, Extension>[Event]> extends (infer F)[] ? F : never>(event: Event, handler: Handler): Plugin<Path, Instance, Config, Context, Omit<Hooks, Event> & { [K in Event]: [...Hooks extends { [k in Event]: any[]; } ? Hooks[K] : [], Handler]; }, Extension>;
+    /**
+     * Defines new properties or methods to be added to the AsterFlow instance.
+     * A função recebe a instância do app e o contexto do plugin, e deve retornar um objeto
+     * com as novas propriedades.
+     */
+    extends<E extends Record<string, any>>(extensionFn: (app: Instance, context: Context) => E): Plugin<Path, Instance, Config, Context, Hooks, Extension & E>;
     /**
      * Builds the final context and hooks from the provided configuration.
      */
     _build(config: any): {
         name: Path;
-        context: Context;
-        hooks: THooks;
+        context: Config & Context;
+        hooks: Hooks;
+        _extensionFn: ((app: Instance, context: Context) => Extension) | undefined;
+        resolvers: Resolver[];
     };
     /**
      * Creates a new Plugin instance. This is the entry point for building a plugin.
      */
-    static create<Path extends string>(options: {
+    static create<Path extends string, Asterflow extends AnyAsterflow>(options: {
         name: Path;
-    }): Plugin<Path, {}, {}, {}>;
+    }): Plugin<Path, Asterflow, {}, {}, {}>;
+    static instance<T extends AnyAsterflow>(): {
+        create: <Path extends string>(options: {
+            name: Path;
+        }) => Plugin<Path, T, {}, {}, {}, {}>;
+    };
 }

package/dist/types/types/plugin.d.ts

@@ -1,29 +1,34 @@
-import type { AsterFlow } from '@asterflow/core';
+import type { AnyAsterflow, ExtendedAsterflow } from '@asterflow/core';
 import type { Request } from '@asterflow/request';
 import type { Response } from '@asterflow/response';
 import type { Plugin } from '../controllers/Plugin';
-export type AnyPlugin = Plugin<string>;
-export type AnyPluginHooks = PluginHooks<any, any, any, any>;
+export type AnyPlugin = Plugin<string, any, any, any, any, any>;
+export type AnyPlugins = Record<string, ResolvedPlugin<AnyPlugin>>;
+export type AnyPluginHooks = PluginHooks<any, any>;
+export type InferPluginExtension<P> = P extends Plugin<any, any, any, any, any, infer Ext> ? Ext : {};
+export type ResolvedPlugin<P extends AnyPlugin> = P extends Plugin<infer Path, any, any, infer Ctx, any, infer Ext> ? {
+    name: Path;
+    context: Ctx;
+    hooks: PluginHooks<any, Ctx, Ext>;
+    _extensionFn?: (app: any, context: Ctx) => Ext;
+    resolvers: Resolver[];
+} : never;
 /**
  * Tipo para extrair o objeto de configuração de um plugin.
  * Ele torna as propriedades com valores padrão opcionais.
  */
-export type ConfigArgument<P extends AnyPlugin> = P extends Plugin<any, any, any, infer C> ? Omit<C, keyof P['defaultConfig']> & Partial<Pick<C, keyof P['defaultConfig'] & keyof C>> : never;
-/**
- * Tipo para o plugin após seu contexto ter sido construído.
- */
-export type ResolvedPlugin<P extends AnyPlugin> = ReturnType<P['_build']>;
+export type ConfigArgument<P extends AnyPlugin> = P extends Plugin<any, any, infer C, any, any> ? Omit<C, keyof P['defaultConfig']> & Partial<Pick<C, keyof P['defaultConfig'] & keyof C>> : never;
 /**
  * Defines the available lifecycle hooks a plugin can register.
  */
-export type PluginHooks<Instance extends AsterFlow<any>, Context extends Record<string, any>, Responser extends Response, Requester extends Request<unknown>> = {
-    beforeInitialize?: ((app: Instance, context: Context) => void | Promise<void>)[];
-    afterInitialize?: ((app: Instance, context: Context) => void | Promise<void>)[];
-    onRequest?: ((request: Requester, response: Responser, context: Context) => void | Promise<void>)[];
-    onResponse?: ((request: Requester, response: Responser, context: Context) => void | Promise<void>)[];
+export type PluginHooks<Instance extends AnyAsterflow, Context extends Record<string, any>, Extension extends Record<string, any> = {}> = {
+    beforeInitialize?: ((app: ExtendedAsterflow<Instance> & Extension, context: Context) => void | Promise<void>)[];
+    afterInitialize?: ((app: ExtendedAsterflow<Instance> & Extension, context: Context) => void | Promise<void>)[];
+    onRequest?: ((request: Request<unknown>, response: Response, context: Context) => void | Promise<void>)[];
+    onResponse?: ((request: Request<unknown>, response: Response, context: Context) => void | Promise<void>)[];
 };
 /**
  * Represents a function that resolves a part of the plugin's context.
  * @internal
  */
-export type Resolver = (config: any, context: any) => Record<string, any>;
+export type Resolver = (config: any, context: any) => Promise<Record<string, any>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asterflow/plugin",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "main": "dist/cjs/index.cjs",
   "module": "dist/mjs/index.js",
   "types": "dist/types/index.d.ts",
@@ -18,9 +18,9 @@
     "node": ">=20"
   },
   "devDependencies": {
-    "@asterflow/core": "1.0.5",
-    "@asterflow/response": "1.0.2",
-    "@asterflow/request": "1.0.5"
+    "@asterflow/core": "1.0.7",
+    "@asterflow/response": "1.0.4",
+    "@asterflow/request": "1.0.7"
   },
   "peerDependencies": {
     "typescript": "^5.8.3"