@decaf-ts/decorator-validation
Version:
simple decorator based validation engine
192 lines • 25.2 kB
JavaScript
import { DefaultFlavour } from "./constants";
// eslint-disable-next-line @typescript-eslint/no-unused-vars
function defaultFlavourResolver(target) {
return DefaultFlavour;
}
/**
* @description A decorator management class that handles flavoured decorators
* @summary The Decoration class provides a builder pattern for creating and managing decorators with different flavours.
* It supports registering, extending, and applying decorators with context-aware flavour resolution.
* The class implements a fluent interface for defining, extending, and applying decorators with different flavours,
* allowing for framework-specific decorator implementations while maintaining a consistent API.
* @template T Type of the decorator (ClassDecorator | PropertyDecorator | MethodDecorator)
* @param {string} [flavour] Optional flavour parameter for the decorator context
* @class
* @category Model
* @example
* ```typescript
* // Create a new decoration for 'component' with default flavour
* const componentDecorator = new Decoration()
* .for('component')
* .define(customComponentDecorator);
*
* // Create a flavoured decoration
* const vueComponent = new Decoration('vue')
* .for('component')
* .define(vueComponentDecorator);
*
* // Apply the decoration
* @componentDecorator
* class MyComponent {}
* ```
* @mermaid
* sequenceDiagram
* participant C as Client
* participant D as Decoration
* participant R as FlavourResolver
* participant F as DecoratorFactory
*
* C->>D: new Decoration(flavour)
* C->>D: for(key)
* C->>D: define(decorators)
* D->>D: register(key, flavour, decorators)
* D->>F: decoratorFactory(key, flavour)
* F->>R: resolve(target)
* R-->>F: resolved flavour
* F->>F: apply decorators
* F-->>C: decorated target
*/
export class Decoration {
/**
* @description Static map of registered decorators
* @summary Stores all registered decorators organized by key and flavour
*/
static { this.decorators = {}; }
/**
* @description Function to resolve flavour from a target
* @summary Resolver function that determines the appropriate flavour for a given target
*/
static { this.flavourResolver = defaultFlavourResolver; }
constructor(flavour = DefaultFlavour) {
this.flavour = flavour;
}
/**
* @description Sets the key for the decoration builder
* @summary Initializes a new decoration chain with the specified key
* @param {string} key The identifier for the decorator
* @return {DecorationBuilderMid} Builder instance for method chaining
*/
for(key) {
this.key = key;
return this;
}
/**
* @description Adds decorators to the current context
* @summary Internal method to add decorators with addon support
* @param {boolean} [addon=false] Whether the decorators are addons
* @param decorators Array of decorators
* @return {this} Current instance for chaining
*/
decorate(addon = false, ...decorators) {
if (!this.key)
throw new Error("key must be provided before decorators can be added");
if ((!decorators || !decorators.length) &&
!addon &&
this.flavour !== DefaultFlavour)
throw new Error("Must provide overrides or addons to override or extend decaf's decorators");
if (this.flavour === DefaultFlavour && addon)
throw new Error("Default flavour cannot be extended");
this[addon ? "extras" : "decorators"] = new Set([
...(this[addon ? "extras" : "decorators"] || new Set()).values(),
...decorators,
]);
return this;
}
/**
* @description Defines the base decorators
* @summary Sets the primary decorators for the current context
* @param decorators Decorators to define
* @return Builder instance for finishing the chain
*/
define(...decorators) {
return this.decorate(false, ...decorators);
}
/**
* @description Extends existing decorators
* @summary Adds additional decorators to the current context
* @param decorators Additional decorators
* @return {DecorationBuilderBuild} Builder instance for building the decorator
*/
extend(...decorators) {
return this.decorate(true, ...decorators);
}
decoratorFactory(key, f = DefaultFlavour) {
const contextDecorator = function contextDecorator(target, propertyKey, descriptor) {
const flavour = Decoration.flavourResolver(target);
let decorators;
const extras = Decoration.decorators[key][flavour]
? Decoration.decorators[key][flavour].extras
: Decoration.decorators[key][DefaultFlavour].extras;
if (Decoration.decorators[key] &&
Decoration.decorators[key][flavour] &&
Decoration.decorators[key][flavour].decorators) {
decorators = Decoration.decorators[key][flavour].decorators;
}
else {
decorators = Decoration.decorators[key][DefaultFlavour].decorators;
}
[
...(decorators ? decorators.values() : []),
...(extras ? extras.values() : []),
].forEach((d) => d(target, propertyKey, descriptor, descriptor));
// return apply(
//
// )(target, propertyKey, descriptor);
};
Object.defineProperty(contextDecorator, "name", {
value: [f, key].join("_decorator_for_"),
writable: false,
});
return contextDecorator;
}
/**
* @description Creates the final decorator function
* @summary Builds and returns the decorator factory function
* @return {function(any, any?, TypedPropertyDescriptor?): any} The generated decorator function
*/
apply() {
if (!this.key)
throw new Error("No key provided for the decoration builder");
Decoration.register(this.key, this.flavour, this.decorators, this.extras);
return this.decoratorFactory(this.key, this.flavour);
}
/**
* @description Registers decorators for a specific key and flavour
* @summary Internal method to store decorators in the static registry
* @param {string} key Decorator key
* @param {string} flavour Decorator flavour
* @param [decorators] Primary decorators
* @param [extras] Additional decorators
*/
static register(key, flavour, decorators, extras) {
if (!key)
throw new Error("No key provided for the decoration builder");
if (!decorators)
throw new Error("No decorators provided for the decoration builder");
if (!flavour)
throw new Error("No flavour provided for the decoration builder");
if (!Decoration.decorators[key])
Decoration.decorators[key] = {};
if (!Decoration.decorators[key][flavour])
Decoration.decorators[key][flavour] = {};
if (decorators)
Decoration.decorators[key][flavour].decorators = decorators;
if (extras)
Decoration.decorators[key][flavour].extras = extras;
}
/**
* @description Sets the global flavour resolver
* @summary Configures the function used to determine decorator flavours
* @param {FlavourResolver} resolver Function to resolve flavours
*/
static setFlavourResolver(resolver) {
Decoration.flavourResolver = resolver;
}
static for(key) {
return new Decoration().for(key);
}
static flavouredAs(flavour) {
return new Decoration(flavour);
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Decoration.js","sourceRoot":"","sources":["../../../src/utils/Decoration.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  DecorationBuilderBuild,\n  DecorationBuilderEnd,\n  DecorationBuilderMid,\n  DecorationBuilderStart,\n  FlavourResolver,\n  IDecorationBuilder,\n} from \"./types\";\nimport { DefaultFlavour } from \"./constants\";\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction defaultFlavourResolver(target: object) {\n  return DefaultFlavour;\n}\n\n/**\n * @description A decorator management class that handles flavoured decorators\n * @summary The Decoration class provides a builder pattern for creating and managing decorators with different flavours.\n * It supports registering, extending, and applying decorators with context-aware flavour resolution.\n * The class implements a fluent interface for defining, extending, and applying decorators with different flavours,\n * allowing for framework-specific decorator implementations while maintaining a consistent API.\n * @template T Type of the decorator (ClassDecorator | PropertyDecorator | MethodDecorator)\n * @param {string} [flavour] Optional flavour parameter for the decorator context\n * @class\n * @category Model\n * @example\n * ```typescript\n * // Create a new decoration for 'component' with default flavour\n * const componentDecorator = new Decoration()\n *   .for('component')\n *   .define(customComponentDecorator);\n *\n * // Create a flavoured decoration\n * const vueComponent = new Decoration('vue')\n *   .for('component')\n *   .define(vueComponentDecorator);\n *\n * // Apply the decoration\n * @componentDecorator\n * class MyComponent {}\n * ```\n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant D as Decoration\n *   participant R as FlavourResolver\n *   participant F as DecoratorFactory\n *\n *   C->>D: new Decoration(flavour)\n *   C->>D: for(key)\n *   C->>D: define(decorators)\n *   D->>D: register(key, flavour, decorators)\n *   D->>F: decoratorFactory(key, flavour)\n *   F->>R: resolve(target)\n *   R-->>F: resolved flavour\n *   F->>F: apply decorators\n *   F-->>C: decorated target\n */\nexport class Decoration implements IDecorationBuilder {\n  /**\n   * @description Static map of registered decorators\n   * @summary Stores all registered decorators organized by key and flavour\n   */\n  private static decorators: Record<\n    string,\n    Record<\n      string,\n      {\n        decorators?: Set<ClassDecorator | PropertyDecorator | MethodDecorator>;\n        extras?: Set<ClassDecorator | PropertyDecorator | MethodDecorator>;\n      }\n    >\n  > = {};\n\n  /**\n   * @description Function to resolve flavour from a target\n   * @summary Resolver function that determines the appropriate flavour for a given target\n   */\n  private static flavourResolver: FlavourResolver = defaultFlavourResolver;\n\n  /**\n   * @description Set of decorators for the current context\n   */\n  private decorators?: Set<\n    ClassDecorator | PropertyDecorator | MethodDecorator\n  >;\n\n  /**\n   * @description Set of additional decorators\n   */\n  private extras?: Set<ClassDecorator | PropertyDecorator | MethodDecorator>;\n\n  /**\n   * @description Current decorator key\n   */\n  private key?: string;\n\n  constructor(private flavour: string = DefaultFlavour) {}\n\n  /**\n   * @description Sets the key for the decoration builder\n   * @summary Initializes a new decoration chain with the specified key\n   * @param {string} key The identifier for the decorator\n   * @return {DecorationBuilderMid} Builder instance for method chaining\n   */\n  for(key: string): DecorationBuilderMid {\n    this.key = key;\n    return this;\n  }\n\n  /**\n   * @description Adds decorators to the current context\n   * @summary Internal method to add decorators with addon support\n   * @param {boolean} [addon=false] Whether the decorators are addons\n   * @param decorators Array of decorators\n   * @return {this} Current instance for chaining\n   */\n  private decorate(\n    addon: boolean = false,\n    ...decorators: (ClassDecorator | PropertyDecorator | MethodDecorator)[]\n  ): this {\n    if (!this.key)\n      throw new Error(\"key must be provided before decorators can be added\");\n    if (\n      (!decorators || !decorators.length) &&\n      !addon &&\n      this.flavour !== DefaultFlavour\n    )\n      throw new Error(\n        \"Must provide overrides or addons to override or extend decaf's decorators\"\n      );\n    if (this.flavour === DefaultFlavour && addon)\n      throw new Error(\"Default flavour cannot be extended\");\n\n    this[addon ? \"extras\" : \"decorators\"] = new Set([\n      ...(this[addon ? \"extras\" : \"decorators\"] || new Set()).values(),\n      ...decorators,\n    ]);\n\n    return this;\n  }\n\n  /**\n   * @description Defines the base decorators\n   * @summary Sets the primary decorators for the current context\n   * @param decorators Decorators to define\n   * @return Builder instance for finishing the chain\n   */\n  define(\n    ...decorators: (ClassDecorator | PropertyDecorator | MethodDecorator)[]\n  ): DecorationBuilderEnd & DecorationBuilderBuild {\n    return this.decorate(false, ...decorators);\n  }\n\n  /**\n   * @description Extends existing decorators\n   * @summary Adds additional decorators to the current context\n   * @param decorators Additional decorators\n   * @return {DecorationBuilderBuild} Builder instance for building the decorator\n   */\n  extend(\n    ...decorators: (ClassDecorator | PropertyDecorator | MethodDecorator)[]\n  ): DecorationBuilderBuild {\n    return this.decorate(true, ...decorators);\n  }\n\n  protected decoratorFactory(key: string, f: string = DefaultFlavour) {\n    const contextDecorator = function contextDecorator(\n      target: object,\n      propertyKey?: any,\n      descriptor?: TypedPropertyDescriptor<any>\n    ) {\n      const flavour = Decoration.flavourResolver(target);\n      let decorators;\n      const extras = Decoration.decorators[key][flavour]\n        ? Decoration.decorators[key][flavour].extras\n        : Decoration.decorators[key][DefaultFlavour].extras;\n      if (\n        Decoration.decorators[key] &&\n        Decoration.decorators[key][flavour] &&\n        Decoration.decorators[key][flavour].decorators\n      ) {\n        decorators = Decoration.decorators[key][flavour].decorators;\n      } else {\n        decorators = Decoration.decorators[key][DefaultFlavour].decorators;\n      }\n      [\n        ...(decorators ? decorators.values() : []),\n        ...(extras ? extras.values() : []),\n      ].forEach((d) => (d as any)(target, propertyKey, descriptor, descriptor));\n      // return apply(\n      //\n      // )(target, propertyKey, descriptor);\n    };\n    Object.defineProperty(contextDecorator, \"name\", {\n      value: [f, key].join(\"_decorator_for_\"),\n      writable: false,\n    });\n    return contextDecorator;\n  }\n\n  /**\n   * @description Creates the final decorator function\n   * @summary Builds and returns the decorator factory function\n   * @return {function(any, any?, TypedPropertyDescriptor?): any} The generated decorator function\n   */\n  apply(): (\n    target: any,\n    propertyKey?: any,\n    descriptor?: TypedPropertyDescriptor<any>\n  ) => any {\n    if (!this.key)\n      throw new Error(\"No key provided for the decoration builder\");\n    Decoration.register(this.key, this.flavour, this.decorators, this.extras);\n    return this.decoratorFactory(this.key, this.flavour);\n  }\n\n  /**\n   * @description Registers decorators for a specific key and flavour\n   * @summary Internal method to store decorators in the static registry\n   * @param {string} key Decorator key\n   * @param {string} flavour Decorator flavour\n   * @param [decorators] Primary decorators\n   * @param [extras] Additional decorators\n   */\n  private static register(\n    key: string,\n    flavour: string,\n    decorators?: Set<ClassDecorator | PropertyDecorator | MethodDecorator>,\n    extras?: Set<ClassDecorator | PropertyDecorator | MethodDecorator>\n  ) {\n    if (!key) throw new Error(\"No key provided for the decoration builder\");\n    if (!decorators)\n      throw new Error(\"No decorators provided for the decoration builder\");\n    if (!flavour)\n      throw new Error(\"No flavour provided for the decoration builder\");\n\n    if (!Decoration.decorators[key]) Decoration.decorators[key] = {};\n    if (!Decoration.decorators[key][flavour])\n      Decoration.decorators[key][flavour] = {};\n    if (decorators) Decoration.decorators[key][flavour].decorators = decorators;\n    if (extras) Decoration.decorators[key][flavour].extras = extras;\n  }\n\n  /**\n   * @description Sets the global flavour resolver\n   * @summary Configures the function used to determine decorator flavours\n   * @param {FlavourResolver} resolver Function to resolve flavours\n   */\n  static setFlavourResolver(resolver: FlavourResolver) {\n    Decoration.flavourResolver = resolver;\n  }\n\n  static for(key: string): DecorationBuilderMid {\n    return new Decoration().for(key);\n  }\n\n  static flavouredAs(flavour: string): DecorationBuilderStart {\n    return new Decoration(flavour);\n  }\n}\n"]}