@decaf-ts/core 0.5.0 → 0.5.2

package/lib/esm/model/decorators.d.ts

@@ -4,73 +4,197 @@ import { OrderDirection } from "../repository/constants";
 import { Constructor, Model } from "@decaf-ts/decorator-validation";
 import { Repo } from "../repository/Repository";
 import { RelationsMetadata } from "./types";
+/**
+ * @description Specifies the database table name for a model
+ * @summary Decorator that sets the table name for a model class in the database
+ * @param {string} tableName - The name of the table in the database
+ * @return {Function} A decorator function that can be applied to a class
+ * @function table
+ * @category Class Decorators
+ */
 export declare function table(tableName: string): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
+/**
+ * @description Specifies the database column name for a model property
+ * @summary Decorator that maps a model property to a specific column name in the database
+ * @param {string} columnName - The name of the column in the database
+ * @return {Function} A decorator function that can be applied to a class property
+ * @function column
+ * @category Property Decorators
+ */
 export declare function column(columnName: string): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
 /**
- * @summary Index Decorator
- * @description properties decorated will the index in the
- * DB for performance in queries
- *
- * @param {OrderDirection[]} [directions]
- * @param {string[]} [compositions]
- *
+ * @description Creates an index on a model property for improved query performance
+ * @summary Decorator that marks a property to be indexed in the database, optionally with specific directions and compositions
+ * @param {OrderDirection[]} [directions] - Optional array of sort directions for the index
+ * @param {string[]} [compositions] - Optional array of property names to create a composite index
+ * @return {Function} A decorator function that can be applied to a class property
  * @function index
+ * @category Property Decorators
  */
 export declare function index(directions?: OrderDirection[], compositions?: string[]): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
-export declare function uniqueOnCreateUpdate<M extends Model, R extends Repo<M, C, F>, V extends object, F extends RepositoryFlags, C extends Context<F>>(this: R, context: Context<F>, data: V, key: keyof M, model: M): Promise<void>;
 /**
- * @summary Unique Decorator
- * @description Tags a property as unique.
- *  No other elements in that table can have the same property value
- *
+ * @description Enforces uniqueness constraint during model creation and update
+ * @summary Internal function used by the unique decorator to check if a property value already exists in the database
+ * @template M - The model type extending Model
+ * @template R - The repository type extending Repo<M, F, C>
+ * @template V - The metadata type
+ * @template F - The repository flags type
+ * @template C - The context type extending Context<F>
+ * @param {R} this - The repository instance
+ * @param {Context<F>} context - The context for the operation
+ * @param {V} data - The metadata for the property
+ * @param key - The property key to check for uniqueness
+ * @param {M} model - The model instance being created or updated
+ * @return {Promise<void>} A promise that resolves when the check is complete or rejects with a ConflictError
+ * @function uniqueOnCreateUpdate
+ * @memberOf module:core
+ */
+export declare function uniqueOnCreateUpdate<M extends Model, R extends Repo<M, F, C>, V extends object, F extends RepositoryFlags, C extends Context<F>>(this: R, context: Context<F>, data: V, key: keyof M, model: M): Promise<void>;
+/**
+ * @description Tags a property as unique
+ * @summary Decorator that ensures a property value is unique across all instances of a model in the database
+ * @return {Function} A decorator function that can be applied to a class property
  * @function unique
- *
- * @memberOf module:wallet-db.Decorators
+ * @category Property Decorators
+ * @example
+ * ```typescript
+ * class User extends BaseModel {
+ *   @unique()
+ *   @required()
+ *   username!: string;
+ * }
+ * ```
  */
 export declare function unique(): (target: object, propertyKey?: string | symbol | unknown, descriptor?: PropertyDescriptor) => void;
-export declare function createdByOnCreateUpdate<M extends Model, R extends Repo<M, C, F>, V extends RelationsMetadata, F extends RepositoryFlags, C extends Context<F>>(this: R, context: Context<F>, data: V, key: keyof M, model: M): Promise<void>;
+/**
+ * @description Handles user identification for ownership tracking
+ * @summary Internal function used by the createdBy and updatedBy decorators to set ownership information
+ * @template M - The model type extending Model
+ * @template R - The repository type extending Repo<M, F, C>
+ * @template V - The relations metadata type extending RelationsMetadata
+ * @template F - The repository flags type
+ * @template C - The context type extending Context<F>
+ * @param {R} this - The repository instance
+ * @param {Context<F>} context - The context for the operation
+ * @param {V} data - The metadata for the property
+ * @param key - The property key to store the user identifier
+ * @param {M} model - The model instance being created or updated
+ * @return {Promise<void>} A promise that rejects with an AuthorizationError if user identification is not supported
+ * @function createdByOnCreateUpdate
+ * @memberOf module:core
+ */
+export declare function createdByOnCreateUpdate<M extends Model, R extends Repo<M, F, C>, V extends RelationsMetadata, F extends RepositoryFlags, C extends Context<F>>(this: R, context: Context<F>, data: V, key: keyof M, model: M): Promise<void>;
+/**
+ * @description Tracks the creator of a model instance
+ * @summary Decorator that marks a property to store the identifier of the user who created the model instance
+ * @return {Function} A decorator function that can be applied to a class property
+ * @function createdBy
+ * @category Property Decorators
+ * @example
+ * ```typescript
+ * class Document extends BaseModel {
+ *   @createdBy()
+ *   creator!: string;
+ * }
+ * ```
+ */
 export declare function createdBy(): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+/**
+ * @description Tracks the last updater of a model instance
+ * @summary Decorator that marks a property to store the identifier of the user who last updated the model instance
+ * @return {Function} A decorator function that can be applied to a class property
+ * @function updatedBy
+ * @category Property Decorators
+ * @example
+ * ```typescript
+ * class Document extends BaseModel {
+ *   @updatedBy()
+ *   lastEditor!: string;
+ * }
+ * ```
+ */
 export declare function updatedBy(): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
 /**
- * @summary One To One relation Decorators
- *
- * @param {Constructor<any>} clazz the {@link Sequence} to use. Defaults to {@link NoneSequence}
- * @param {CascadeMetadata} [cascadeOptions]
- * @param {boolean} populate If true, replaces the specified key in the document with the corresponding record from the database
- *
- * @function onToOne
- *
- * @memberOf module:wallet-db.Decorators
- *
+ * @description Defines a one-to-one relationship between models
+ * @summary Decorator that establishes a one-to-one relationship between the current model and another model
+ * @template M - The related model type extending Model
+ * @param {Constructor<M>} clazz - The constructor of the related model class
+ * @param {CascadeMetadata} [cascadeOptions=DefaultCascade] - Options for cascading operations (create, update, delete)
+ * @param {boolean} [populate=true] - If true, automatically populates the relationship when the model is retrieved
+ * @return {Function} A decorator function that can be applied to a class property
+ * @function oneToOne
+ * @category Property Decorators
+ * @example
+ * ```typescript
+ * class User extends BaseModel {
+ *   @oneToOne(Profile)
+ *   profile!: string | Profile;
+ * }
+ *
+ * class Profile extends BaseModel {
+ *   @required()
+ *   bio!: string;
+ * }
+ * ```
  * @see oneToMany
  * @see manyToOne
  */
 export declare function oneToOne<M extends Model>(clazz: Constructor<M>, cascadeOptions?: CascadeMetadata, populate?: boolean): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
 /**
- * @summary One To Many relation Decorators
- *
- * @param {Constructor<any>} clazz the {@link Sequence} to use. Defaults to {@link NoneSequence}
- * @param {CascadeMetadata} [cascadeOptions]
- *
+ * @description Defines a one-to-many relationship between models
+ * @summary Decorator that establishes a one-to-many relationship between the current model and multiple instances of another model
+ * @template M - The related model type extending Model
+ * @param {Constructor<M>} clazz - The constructor of the related model class
+ * @param {CascadeMetadata} [cascadeOptions=DefaultCascade] - Options for cascading operations (create, update, delete)
+ * @param {boolean} [populate=true] - If true, automatically populates the relationship when the model is retrieved
+ * @return {Function} A decorator function that can be applied to a class property
  * @function oneToMany
- *
- * @memberOf module:wallet-db.Decorators
- *
+ * @category Property Decorators
+ * @example
+ * ```typescript
+ * class Author extends BaseModel {
+ *   @required()
+ *   name!: string;
+ *
+ *   @oneToMany(Book)
+ *   books!: string[] | Book[];
+ * }
+ *
+ * class Book extends BaseModel {
+ *   @required()
+ *   title!: string;
+ * }
+ * ```
  * @see oneToOne
  * @see manyToOne
  */
 export declare function oneToMany<M extends Model>(clazz: Constructor<M>, cascadeOptions?: CascadeMetadata, populate?: boolean): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
 /**
- * @summary Many To One relation Decorators
- *
- * @param {Constructor<any>} clazz the {@link Sequence} to use. Defaults to {@link NoneSequence}
- * @param {CascadeMetadata} [cascadeOptions]
- *
+ * @description Defines a many-to-one relationship between models
+ * @summary Decorator that establishes a many-to-one relationship between multiple instances of the current model and another model
+ * @template M - The related model type extending Model
+ * @param {Constructor<M>} clazz - The constructor of the related model class
+ * @param {CascadeMetadata} [cascadeOptions=DefaultCascade] - Options for cascading operations (create, update, delete)
+ * @param {boolean} [populate=true] - If true, automatically populates the relationship when the model is retrieved
+ * @return {Function} A decorator function that can be applied to a class property
  * @function manyToOne
- *
- * @memberOf module:wallet-db.Decorators
- *
+ * @category Property Decorators
+ * @example
+ * ```typescript
+ * class Book extends BaseModel {
+ *   @required()
+ *   title!: string;
+ *
+ *   @manyToOne(Author)
+ *   author!: string | Author;
+ * }
+ *
+ * class Author extends BaseModel {
+ *   @required()
+ *   name!: string;
+ * }
+ * ```
  * @see oneToMany
  * @see oneToOne
  */
-export declare function manyToOne(clazz: Constructor<any>, cascadeOptions?: CascadeMetadata, populate?: boolean): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;
+export declare function manyToOne<M extends Model>(clazz: Constructor<M>, cascadeOptions?: CascadeMetadata, populate?: boolean): (target: any, propertyKey?: any, descriptor?: TypedPropertyDescriptor<any>) => any;

package/lib/esm/model/decorators.js

@@ -7,22 +7,37 @@ import { Adapter } from "../persistence/Adapter";
 import { Repository } from "../repository/Repository";
 import { Condition } from "../query/Condition";
 import { oneToManyOnCreate, oneToManyOnDelete, oneToManyOnUpdate, oneToOneOnCreate, oneToOneOnDelete, oneToOneOnUpdate, populate as pop, } from "./construction";
-import { UnsupportedError } from "../persistence/errors";
+import { AuthorizationError } from "../utils";
+/**
+ * @description Specifies the database table name for a model
+ * @summary Decorator that sets the table name for a model class in the database
+ * @param {string} tableName - The name of the table in the database
+ * @return {Function} A decorator function that can be applied to a class
+ * @function table
+ * @category Class Decorators
+ */
 export function table(tableName) {
     return metadata(Adapter.key(PersistenceKeys.TABLE), tableName);
 }
+/**
+ * @description Specifies the database column name for a model property
+ * @summary Decorator that maps a model property to a specific column name in the database
+ * @param {string} columnName - The name of the column in the database
+ * @return {Function} A decorator function that can be applied to a class property
+ * @function column
+ * @category Property Decorators
+ */
 export function column(columnName) {
     return propMetadata(Adapter.key(PersistenceKeys.COLUMN), columnName);
 }
 /**
- * @summary Index Decorator
- * @description properties decorated will the index in the
- * DB for performance in queries
- *
- * @param {OrderDirection[]} [directions]
- * @param {string[]} [compositions]
- *
+ * @description Creates an index on a model property for improved query performance
+ * @summary Decorator that marks a property to be indexed in the database, optionally with specific directions and compositions
+ * @param {OrderDirection[]} [directions] - Optional array of sort directions for the index
+ * @param {string[]} [compositions] - Optional array of property names to create a composite index
+ * @return {Function} A decorator function that can be applied to a class property
  * @function index
+ * @category Property Decorators
  */
 export function index(directions, compositions) {
     return propMetadata(Repository.key(`${PersistenceKeys.INDEX}${compositions && compositions.length ? `.${compositions.join(".")}` : ""}`), {
@@ -30,6 +45,23 @@ export function index(directions, compositions) {
         compositions: compositions,
     });
 }
+/**
+ * @description Enforces uniqueness constraint during model creation and update
+ * @summary Internal function used by the unique decorator to check if a property value already exists in the database
+ * @template M - The model type extending Model
+ * @template R - The repository type extending Repo<M, F, C>
+ * @template V - The metadata type
+ * @template F - The repository flags type
+ * @template C - The context type extending Context<F>
+ * @param {R} this - The repository instance
+ * @param {Context<F>} context - The context for the operation
+ * @param {V} data - The metadata for the property
+ * @param key - The property key to check for uniqueness
+ * @param {M} model - The model instance being created or updated
+ * @return {Promise<void>} A promise that resolves when the check is complete or rejects with a ConflictError
+ * @function uniqueOnCreateUpdate
+ * @memberOf module:core
+ */
 export async function uniqueOnCreateUpdate(context, data, key, model) {
     if (!model[key])
         return;
@@ -40,17 +72,40 @@ export async function uniqueOnCreateUpdate(context, data, key, model) {
         throw new ConflictError(`model already exists with property ${key} equal to ${JSON.stringify(model[key], undefined, 2)}`);
 }
 /**
- * @summary Unique Decorator
- * @description Tags a property as unique.
- *  No other elements in that table can have the same property value
- *
+ * @description Tags a property as unique
+ * @summary Decorator that ensures a property value is unique across all instances of a model in the database
+ * @return {Function} A decorator function that can be applied to a class property
  * @function unique
- *
- * @memberOf module:wallet-db.Decorators
+ * @category Property Decorators
+ * @example
+ * ```typescript
+ * class User extends BaseModel {
+ *   @unique()
+ *   @required()
+ *   username!: string;
+ * }
+ * ```
  */
 export function unique() {
     return apply(onCreateUpdate(uniqueOnCreateUpdate), propMetadata(Repository.key(PersistenceKeys.UNIQUE), {}));
 }
+/**
+ * @description Handles user identification for ownership tracking
+ * @summary Internal function used by the createdBy and updatedBy decorators to set ownership information
+ * @template M - The model type extending Model
+ * @template R - The repository type extending Repo<M, F, C>
+ * @template V - The relations metadata type extending RelationsMetadata
+ * @template F - The repository flags type
+ * @template C - The context type extending Context<F>
+ * @param {R} this - The repository instance
+ * @param {Context<F>} context - The context for the operation
+ * @param {V} data - The metadata for the property
+ * @param key - The property key to store the user identifier
+ * @param {M} model - The model instance being created or updated
+ * @return {Promise<void>} A promise that rejects with an AuthorizationError if user identification is not supported
+ * @function createdByOnCreateUpdate
+ * @memberOf module:core
+ */
 export async function createdByOnCreateUpdate(
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 context, 
@@ -60,14 +115,42 @@ data,
 key, 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 model) {
-    throw new UnsupportedError("This adapter does not support user identification");
+    throw new AuthorizationError("This adapter does not support user identification");
 }
+/**
+ * @description Tracks the creator of a model instance
+ * @summary Decorator that marks a property to store the identifier of the user who created the model instance
+ * @return {Function} A decorator function that can be applied to a class property
+ * @function createdBy
+ * @category Property Decorators
+ * @example
+ * ```typescript
+ * class Document extends BaseModel {
+ *   @createdBy()
+ *   creator!: string;
+ * }
+ * ```
+ */
 export function createdBy() {
     const key = Repository.key(PersistenceKeys.CREATED_BY);
     return Decoration.for(key)
         .define(onCreate(createdByOnCreateUpdate), propMetadata(key, {}))
         .apply();
 }
+/**
+ * @description Tracks the last updater of a model instance
+ * @summary Decorator that marks a property to store the identifier of the user who last updated the model instance
+ * @return {Function} A decorator function that can be applied to a class property
+ * @function updatedBy
+ * @category Property Decorators
+ * @example
+ * ```typescript
+ * class Document extends BaseModel {
+ *   @updatedBy()
+ *   lastEditor!: string;
+ * }
+ * ```
+ */
 export function updatedBy() {
     const key = Repository.key(PersistenceKeys.UPDATED_BY);
     return Decoration.for(key)
@@ -75,16 +158,27 @@ export function updatedBy() {
         .apply();
 }
 /**
- * @summary One To One relation Decorators
- *
- * @param {Constructor<any>} clazz the {@link Sequence} to use. Defaults to {@link NoneSequence}
- * @param {CascadeMetadata} [cascadeOptions]
- * @param {boolean} populate If true, replaces the specified key in the document with the corresponding record from the database
- *
- * @function onToOne
- *
- * @memberOf module:wallet-db.Decorators
+ * @description Defines a one-to-one relationship between models
+ * @summary Decorator that establishes a one-to-one relationship between the current model and another model
+ * @template M - The related model type extending Model
+ * @param {Constructor<M>} clazz - The constructor of the related model class
+ * @param {CascadeMetadata} [cascadeOptions=DefaultCascade] - Options for cascading operations (create, update, delete)
+ * @param {boolean} [populate=true] - If true, automatically populates the relationship when the model is retrieved
+ * @return {Function} A decorator function that can be applied to a class property
+ * @function oneToOne
+ * @category Property Decorators
+ * @example
+ * ```typescript
+ * class User extends BaseModel {
+ *   @oneToOne(Profile)
+ *   profile!: string | Profile;
+ * }
  *
+ * class Profile extends BaseModel {
+ *   @required()
+ *   bio!: string;
+ * }
+ * ```
  * @see oneToMany
  * @see manyToOne
  */
@@ -101,15 +195,30 @@ export function oneToOne(clazz, cascadeOptions = DefaultCascade, populate = true
         .apply();
 }
 /**
- * @summary One To Many relation Decorators
- *
- * @param {Constructor<any>} clazz the {@link Sequence} to use. Defaults to {@link NoneSequence}
- * @param {CascadeMetadata} [cascadeOptions]
- *
+ * @description Defines a one-to-many relationship between models
+ * @summary Decorator that establishes a one-to-many relationship between the current model and multiple instances of another model
+ * @template M - The related model type extending Model
+ * @param {Constructor<M>} clazz - The constructor of the related model class
+ * @param {CascadeMetadata} [cascadeOptions=DefaultCascade] - Options for cascading operations (create, update, delete)
+ * @param {boolean} [populate=true] - If true, automatically populates the relationship when the model is retrieved
+ * @return {Function} A decorator function that can be applied to a class property
  * @function oneToMany
+ * @category Property Decorators
+ * @example
+ * ```typescript
+ * class Author extends BaseModel {
+ *   @required()
+ *   name!: string;
  *
- * @memberOf module:wallet-db.Decorators
+ *   @oneToMany(Book)
+ *   books!: string[] | Book[];
+ * }
  *
+ * class Book extends BaseModel {
+ *   @required()
+ *   title!: string;
+ * }
+ * ```
  * @see oneToOne
  * @see manyToOne
  */
@@ -128,15 +237,30 @@ export function oneToMany(clazz, cascadeOptions = DefaultCascade, populate = tru
         .apply();
 }
 /**
- * @summary Many To One relation Decorators
- *
- * @param {Constructor<any>} clazz the {@link Sequence} to use. Defaults to {@link NoneSequence}
- * @param {CascadeMetadata} [cascadeOptions]
- *
+ * @description Defines a many-to-one relationship between models
+ * @summary Decorator that establishes a many-to-one relationship between multiple instances of the current model and another model
+ * @template M - The related model type extending Model
+ * @param {Constructor<M>} clazz - The constructor of the related model class
+ * @param {CascadeMetadata} [cascadeOptions=DefaultCascade] - Options for cascading operations (create, update, delete)
+ * @param {boolean} [populate=true] - If true, automatically populates the relationship when the model is retrieved
+ * @return {Function} A decorator function that can be applied to a class property
  * @function manyToOne
+ * @category Property Decorators
+ * @example
+ * ```typescript
+ * class Book extends BaseModel {
+ *   @required()
+ *   title!: string;
  *
- * @memberOf module:wallet-db.Decorators
+ *   @manyToOne(Author)
+ *   author!: string | Author;
+ * }
  *
+ * class Author extends BaseModel {
+ *   @required()
+ *   name!: string;
+ * }
+ * ```
  * @see oneToMany
  * @see oneToOne
  */
@@ -157,4 +281,4 @@ export function manyToOne(clazz, cascadeOptions = DefaultCascade, populate = tru
     propMetadata(key, metadata))
         .apply();
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../../../src/model/decorators.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ConflictError,\n  onCreate,\n  onCreateUpdate,\n  onDelete,\n  onUpdate,\n  afterAny,\n  RepositoryFlags,\n  Context,\n} from \"@decaf-ts/db-decorators\";\nimport { apply, metadata } from \"@decaf-ts/reflection\";\nimport { PersistenceKeys } from \"../persistence/constants\";\nimport { CascadeMetadata, IndexMetadata } from \"../repository/types\";\nimport { DefaultCascade, OrderDirection } from \"../repository/constants\";\nimport {\n  Constructor,\n  Decoration,\n  list,\n  Model,\n  prop,\n  propMetadata,\n  type,\n} from \"@decaf-ts/decorator-validation\";\nimport { Adapter } from \"../persistence/Adapter\";\nimport { Repo, Repository } from \"../repository/Repository\";\nimport { Condition } from \"../query/Condition\";\nimport { RelationsMetadata } from \"./types\";\nimport {\n  oneToManyOnCreate,\n  oneToManyOnDelete,\n  oneToManyOnUpdate,\n  oneToOneOnCreate,\n  oneToOneOnDelete,\n  oneToOneOnUpdate,\n  populate as pop,\n} from \"./construction\";\nimport { UnsupportedError } from \"../persistence/errors\";\n\nexport function table(tableName: string) {\n  return metadata(Adapter.key(PersistenceKeys.TABLE), tableName);\n}\n\nexport function column(columnName: string) {\n  return propMetadata(Adapter.key(PersistenceKeys.COLUMN), columnName);\n}\n\n/**\n * @summary Index Decorator\n * @description properties decorated will the index in the\n * DB for performance in queries\n *\n * @param {OrderDirection[]} [directions]\n * @param {string[]} [compositions]\n *\n * @function index\n */\nexport function index(directions?: OrderDirection[], compositions?: string[]) {\n  return propMetadata(\n    Repository.key(\n      `${PersistenceKeys.INDEX}${compositions && compositions.length ? `.${compositions.join(\".\")}` : \"\"}`\n    ),\n    {\n      directions: directions,\n      compositions: compositions,\n    } as IndexMetadata\n  );\n}\n\nexport async function uniqueOnCreateUpdate<\n  M extends Model,\n  R extends Repo<M, C, F>,\n  V extends object,\n  F extends RepositoryFlags,\n  C extends Context<F>,\n>(\n  this: R,\n  context: Context<F>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  if (!(model as any)[key]) return;\n  const existing = await this.select()\n    .where(Condition.attribute(key as string).eq((model as any)[key]))\n    .execute<M[]>();\n  if (existing.length)\n    throw new ConflictError(\n      `model already exists with property ${key as string} equal to ${JSON.stringify((model as any)[key], undefined, 2)}`\n    );\n}\n\n/**\n * @summary Unique Decorator\n * @description Tags a property as unique.\n *  No other elements in that table can have the same property value\n *\n * @function unique\n *\n * @memberOf module:wallet-db.Decorators\n */\nexport function unique() {\n  return apply(\n    onCreateUpdate(uniqueOnCreateUpdate),\n    propMetadata(Repository.key(PersistenceKeys.UNIQUE), {})\n  );\n}\n\nexport async function createdByOnCreateUpdate<\n  M extends Model,\n  R extends Repo<M, C, F>,\n  V extends RelationsMetadata,\n  F extends RepositoryFlags,\n  C extends Context<F>,\n>(\n  this: R,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  context: Context<F>,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  data: V,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  key: keyof M,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  model: M\n): Promise<void> {\n  throw new UnsupportedError(\n    \"This adapter does not support user identification\"\n  );\n}\n\nexport function createdBy() {\n  const key = Repository.key(PersistenceKeys.CREATED_BY);\n  return Decoration.for(key)\n    .define(onCreate(createdByOnCreateUpdate), propMetadata(key, {}))\n    .apply();\n}\n\nexport function updatedBy() {\n  const key = Repository.key(PersistenceKeys.UPDATED_BY);\n  return Decoration.for(key)\n    .define(onCreateUpdate(createdByOnCreateUpdate), propMetadata(key, {}))\n    .apply();\n}\n\n/**\n * @summary One To One relation Decorators\n *\n * @param {Constructor<any>} clazz the {@link Sequence} to use. Defaults to {@link NoneSequence}\n * @param {CascadeMetadata} [cascadeOptions]\n * @param {boolean} populate If true, replaces the specified key in the document with the corresponding record from the database\n *\n * @function onToOne\n *\n * @memberOf module:wallet-db.Decorators\n *\n * @see oneToMany\n * @see manyToOne\n */\nexport function oneToOne<M extends Model>(\n  clazz: Constructor<M>,\n  cascadeOptions: CascadeMetadata = DefaultCascade,\n  populate: boolean = true\n) {\n  Model.register(clazz);\n  const metadata: RelationsMetadata = {\n    class: clazz.name,\n    cascade: cascadeOptions,\n    populate: populate,\n  };\n  const key = Repository.key(PersistenceKeys.ONE_TO_ONE);\n  return Decoration.for(key)\n    .define(\n      prop(PersistenceKeys.RELATIONS),\n      type([clazz.name, String.name, Number.name, BigInt.name]),\n      onCreate(oneToOneOnCreate, metadata),\n      onUpdate(oneToOneOnUpdate, metadata),\n      onDelete(oneToOneOnDelete, metadata),\n      afterAny(pop, metadata),\n      propMetadata(key, metadata)\n    )\n    .apply();\n}\n\n/**\n * @summary One To Many relation Decorators\n *\n * @param {Constructor<any>} clazz the {@link Sequence} to use. Defaults to {@link NoneSequence}\n * @param {CascadeMetadata} [cascadeOptions]\n *\n * @function oneToMany\n *\n * @memberOf module:wallet-db.Decorators\n *\n * @see oneToOne\n * @see manyToOne\n */\nexport function oneToMany<M extends Model>(\n  clazz: Constructor<M>,\n  cascadeOptions: CascadeMetadata = DefaultCascade,\n  populate: boolean = true\n) {\n  Model.register(clazz);\n  const metadata: RelationsMetadata = {\n    class: clazz.name,\n    cascade: cascadeOptions,\n    populate: populate,\n  };\n  const key = Repository.key(PersistenceKeys.ONE_TO_MANY);\n  return Decoration.for(key)\n    .define(\n      prop(PersistenceKeys.RELATIONS),\n      // @ts-expect-error purposeful override\n      list([clazz, String, Number, BigInt]),\n      onCreate(oneToManyOnCreate, metadata),\n      onUpdate(oneToManyOnUpdate, metadata),\n      onDelete(oneToManyOnDelete, metadata),\n      afterAny(pop, metadata),\n      propMetadata(key, metadata)\n    )\n    .apply();\n}\n\n/**\n * @summary Many To One relation Decorators\n *\n * @param {Constructor<any>} clazz the {@link Sequence} to use. Defaults to {@link NoneSequence}\n * @param {CascadeMetadata} [cascadeOptions]\n *\n * @function manyToOne\n *\n * @memberOf module:wallet-db.Decorators\n *\n * @see oneToMany\n * @see oneToOne\n */\nexport function manyToOne(\n  clazz: Constructor<any>,\n  cascadeOptions: CascadeMetadata = DefaultCascade,\n  populate = true\n) {\n  Model.register(clazz);\n  const metadata: RelationsMetadata = {\n    class: clazz.name,\n    cascade: cascadeOptions,\n    populate: populate,\n  };\n  const key = Repository.key(PersistenceKeys.MANY_TO_ONE);\n  return Decoration.for(key)\n    .define(\n      prop(PersistenceKeys.RELATIONS),\n      type([clazz.name, String.name, Number.name, BigInt.name]),\n      // onCreate(oneToManyOnCreate, metadata),\n      // onUpdate(oneToManyOnUpdate, metadata),\n      // onDelete(oneToManyOnDelete, metadata),\n      // afterAll(populate, metadata),\n      propMetadata(key, metadata)\n    )\n    .apply();\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../../../src/model/decorators.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ConflictError,\n  onCreate,\n  onCreateUpdate,\n  onDelete,\n  onUpdate,\n  afterAny,\n  RepositoryFlags,\n  Context,\n} from \"@decaf-ts/db-decorators\";\nimport { apply, metadata } from \"@decaf-ts/reflection\";\nimport { PersistenceKeys } from \"../persistence/constants\";\nimport { CascadeMetadata, IndexMetadata } from \"../repository/types\";\nimport { DefaultCascade, OrderDirection } from \"../repository/constants\";\nimport {\n  Constructor,\n  Decoration,\n  list,\n  Model,\n  prop,\n  propMetadata,\n  type,\n} from \"@decaf-ts/decorator-validation\";\nimport { Adapter } from \"../persistence/Adapter\";\nimport { Repo, Repository } from \"../repository/Repository\";\nimport { Condition } from \"../query/Condition\";\nimport { RelationsMetadata } from \"./types\";\nimport {\n  oneToManyOnCreate,\n  oneToManyOnDelete,\n  oneToManyOnUpdate,\n  oneToOneOnCreate,\n  oneToOneOnDelete,\n  oneToOneOnUpdate,\n  populate as pop,\n} from \"./construction\";\nimport { AuthorizationError } from \"../utils\";\n\n/**\n * @description Specifies the database table name for a model\n * @summary Decorator that sets the table name for a model class in the database\n * @param {string} tableName - The name of the table in the database\n * @return {Function} A decorator function that can be applied to a class\n * @function table\n * @category Class Decorators\n */\nexport function table(tableName: string) {\n  return metadata(Adapter.key(PersistenceKeys.TABLE), tableName);\n}\n\n/**\n * @description Specifies the database column name for a model property\n * @summary Decorator that maps a model property to a specific column name in the database\n * @param {string} columnName - The name of the column in the database\n * @return {Function} A decorator function that can be applied to a class property\n * @function column\n * @category Property Decorators\n */\nexport function column(columnName: string) {\n  return propMetadata(Adapter.key(PersistenceKeys.COLUMN), columnName);\n}\n\n/**\n * @description Creates an index on a model property for improved query performance\n * @summary Decorator that marks a property to be indexed in the database, optionally with specific directions and compositions\n * @param {OrderDirection[]} [directions] - Optional array of sort directions for the index\n * @param {string[]} [compositions] - Optional array of property names to create a composite index\n * @return {Function} A decorator function that can be applied to a class property\n * @function index\n * @category Property Decorators\n */\nexport function index(directions?: OrderDirection[], compositions?: string[]) {\n  return propMetadata(\n    Repository.key(\n      `${PersistenceKeys.INDEX}${compositions && compositions.length ? `.${compositions.join(\".\")}` : \"\"}`\n    ),\n    {\n      directions: directions,\n      compositions: compositions,\n    } as IndexMetadata\n  );\n}\n\n/**\n * @description Enforces uniqueness constraint during model creation and update\n * @summary Internal function used by the unique decorator to check if a property value already exists in the database\n * @template M - The model type extending Model\n * @template R - The repository type extending Repo<M, F, C>\n * @template V - The metadata type\n * @template F - The repository flags type\n * @template C - The context type extending Context<F>\n * @param {R} this - The repository instance\n * @param {Context<F>} context - The context for the operation\n * @param {V} data - The metadata for the property\n * @param key - The property key to check for uniqueness\n * @param {M} model - The model instance being created or updated\n * @return {Promise<void>} A promise that resolves when the check is complete or rejects with a ConflictError\n * @function uniqueOnCreateUpdate\n * @memberOf module:core\n */\nexport async function uniqueOnCreateUpdate<\n  M extends Model,\n  R extends Repo<M, F, C>,\n  V extends object,\n  F extends RepositoryFlags,\n  C extends Context<F>,\n>(\n  this: R,\n  context: Context<F>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  if (!(model as any)[key]) return;\n  const existing = await this.select()\n    .where(Condition.attribute(key).eq(model[key]))\n    .execute();\n  if (existing.length)\n    throw new ConflictError(\n      `model already exists with property ${key as string} equal to ${JSON.stringify((model as any)[key], undefined, 2)}`\n    );\n}\n\n/**\n * @description Tags a property as unique\n * @summary Decorator that ensures a property value is unique across all instances of a model in the database\n * @return {Function} A decorator function that can be applied to a class property\n * @function unique\n * @category Property Decorators\n * @example\n * ```typescript\n * class User extends BaseModel {\n *   @unique()\n *   @required()\n *   username!: string;\n * }\n * ```\n */\nexport function unique() {\n  return apply(\n    onCreateUpdate(uniqueOnCreateUpdate),\n    propMetadata(Repository.key(PersistenceKeys.UNIQUE), {})\n  );\n}\n\n/**\n * @description Handles user identification for ownership tracking\n * @summary Internal function used by the createdBy and updatedBy decorators to set ownership information\n * @template M - The model type extending Model\n * @template R - The repository type extending Repo<M, F, C>\n * @template V - The relations metadata type extending RelationsMetadata\n * @template F - The repository flags type\n * @template C - The context type extending Context<F>\n * @param {R} this - The repository instance\n * @param {Context<F>} context - The context for the operation\n * @param {V} data - The metadata for the property\n * @param key - The property key to store the user identifier\n * @param {M} model - The model instance being created or updated\n * @return {Promise<void>} A promise that rejects with an AuthorizationError if user identification is not supported\n * @function createdByOnCreateUpdate\n * @memberOf module:core\n */\nexport async function createdByOnCreateUpdate<\n  M extends Model,\n  R extends Repo<M, F, C>,\n  V extends RelationsMetadata,\n  F extends RepositoryFlags,\n  C extends Context<F>,\n>(\n  this: R,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  context: Context<F>,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  data: V,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  key: keyof M,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  model: M\n): Promise<void> {\n  throw new AuthorizationError(\n    \"This adapter does not support user identification\"\n  );\n}\n\n/**\n * @description Tracks the creator of a model instance\n * @summary Decorator that marks a property to store the identifier of the user who created the model instance\n * @return {Function} A decorator function that can be applied to a class property\n * @function createdBy\n * @category Property Decorators\n * @example\n * ```typescript\n * class Document extends BaseModel {\n *   @createdBy()\n *   creator!: string;\n * }\n * ```\n */\nexport function createdBy() {\n  const key = Repository.key(PersistenceKeys.CREATED_BY);\n  return Decoration.for(key)\n    .define(onCreate(createdByOnCreateUpdate), propMetadata(key, {}))\n    .apply();\n}\n\n/**\n * @description Tracks the last updater of a model instance\n * @summary Decorator that marks a property to store the identifier of the user who last updated the model instance\n * @return {Function} A decorator function that can be applied to a class property\n * @function updatedBy\n * @category Property Decorators\n * @example\n * ```typescript\n * class Document extends BaseModel {\n *   @updatedBy()\n *   lastEditor!: string;\n * }\n * ```\n */\nexport function updatedBy() {\n  const key = Repository.key(PersistenceKeys.UPDATED_BY);\n  return Decoration.for(key)\n    .define(onCreateUpdate(createdByOnCreateUpdate), propMetadata(key, {}))\n    .apply();\n}\n\n/**\n * @description Defines a one-to-one relationship between models\n * @summary Decorator that establishes a one-to-one relationship between the current model and another model\n * @template M - The related model type extending Model\n * @param {Constructor<M>} clazz - The constructor of the related model class\n * @param {CascadeMetadata} [cascadeOptions=DefaultCascade] - Options for cascading operations (create, update, delete)\n * @param {boolean} [populate=true] - If true, automatically populates the relationship when the model is retrieved\n * @return {Function} A decorator function that can be applied to a class property\n * @function oneToOne\n * @category Property Decorators\n * @example\n * ```typescript\n * class User extends BaseModel {\n *   @oneToOne(Profile)\n *   profile!: string | Profile;\n * }\n *\n * class Profile extends BaseModel {\n *   @required()\n *   bio!: string;\n * }\n * ```\n * @see oneToMany\n * @see manyToOne\n */\nexport function oneToOne<M extends Model>(\n  clazz: Constructor<M>,\n  cascadeOptions: CascadeMetadata = DefaultCascade,\n  populate: boolean = true\n) {\n  Model.register(clazz);\n  const metadata: RelationsMetadata = {\n    class: clazz.name,\n    cascade: cascadeOptions,\n    populate: populate,\n  };\n  const key = Repository.key(PersistenceKeys.ONE_TO_ONE);\n  return Decoration.for(key)\n    .define(\n      prop(PersistenceKeys.RELATIONS),\n      type([clazz.name, String.name, Number.name, BigInt.name]),\n      onCreate(oneToOneOnCreate, metadata),\n      onUpdate(oneToOneOnUpdate, metadata),\n      onDelete(oneToOneOnDelete, metadata),\n      afterAny(pop, metadata),\n      propMetadata(key, metadata)\n    )\n    .apply();\n}\n\n/**\n * @description Defines a one-to-many relationship between models\n * @summary Decorator that establishes a one-to-many relationship between the current model and multiple instances of another model\n * @template M - The related model type extending Model\n * @param {Constructor<M>} clazz - The constructor of the related model class\n * @param {CascadeMetadata} [cascadeOptions=DefaultCascade] - Options for cascading operations (create, update, delete)\n * @param {boolean} [populate=true] - If true, automatically populates the relationship when the model is retrieved\n * @return {Function} A decorator function that can be applied to a class property\n * @function oneToMany\n * @category Property Decorators\n * @example\n * ```typescript\n * class Author extends BaseModel {\n *   @required()\n *   name!: string;\n *\n *   @oneToMany(Book)\n *   books!: string[] | Book[];\n * }\n *\n * class Book extends BaseModel {\n *   @required()\n *   title!: string;\n * }\n * ```\n * @see oneToOne\n * @see manyToOne\n */\nexport function oneToMany<M extends Model>(\n  clazz: Constructor<M>,\n  cascadeOptions: CascadeMetadata = DefaultCascade,\n  populate: boolean = true\n) {\n  Model.register(clazz);\n  const metadata: RelationsMetadata = {\n    class: clazz.name,\n    cascade: cascadeOptions,\n    populate: populate,\n  };\n  const key = Repository.key(PersistenceKeys.ONE_TO_MANY);\n  return Decoration.for(key)\n    .define(\n      prop(PersistenceKeys.RELATIONS),\n      // @ts-expect-error purposeful override\n      list([clazz, String, Number, BigInt]),\n      onCreate(oneToManyOnCreate, metadata),\n      onUpdate(oneToManyOnUpdate, metadata),\n      onDelete(oneToManyOnDelete, metadata),\n      afterAny(pop, metadata),\n      propMetadata(key, metadata)\n    )\n    .apply();\n}\n\n/**\n * @description Defines a many-to-one relationship between models\n * @summary Decorator that establishes a many-to-one relationship between multiple instances of the current model and another model\n * @template M - The related model type extending Model\n * @param {Constructor<M>} clazz - The constructor of the related model class\n * @param {CascadeMetadata} [cascadeOptions=DefaultCascade] - Options for cascading operations (create, update, delete)\n * @param {boolean} [populate=true] - If true, automatically populates the relationship when the model is retrieved\n * @return {Function} A decorator function that can be applied to a class property\n * @function manyToOne\n * @category Property Decorators\n * @example\n * ```typescript\n * class Book extends BaseModel {\n *   @required()\n *   title!: string;\n *\n *   @manyToOne(Author)\n *   author!: string | Author;\n * }\n *\n * class Author extends BaseModel {\n *   @required()\n *   name!: string;\n * }\n * ```\n * @see oneToMany\n * @see oneToOne\n */\nexport function manyToOne<M extends Model>(\n  clazz: Constructor<M>,\n  cascadeOptions: CascadeMetadata = DefaultCascade,\n  populate = true\n) {\n  Model.register(clazz);\n  const metadata: RelationsMetadata = {\n    class: clazz.name,\n    cascade: cascadeOptions,\n    populate: populate,\n  };\n  const key = Repository.key(PersistenceKeys.MANY_TO_ONE);\n  return Decoration.for(key)\n    .define(\n      prop(PersistenceKeys.RELATIONS),\n      type([clazz.name, String.name, Number.name, BigInt.name]),\n      // onCreate(oneToManyOnCreate, metadata),\n      // onUpdate(oneToManyOnUpdate, metadata),\n      // onDelete(oneToManyOnDelete, metadata),\n      // afterAll(populate, metadata),\n      propMetadata(key, metadata)\n    )\n    .apply();\n}\n"]}

package/lib/esm/model/index.js

@@ -1,6 +1,5 @@
 export * from "./BaseModel";
 export * from "./construction";
 export * from "./decorators";
-// export * from "./IdentifiedBaseModel";
 export * from "./types";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbW9kZWwvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLGNBQWMsQ0FBQztBQUM3Qix5Q0FBeUM7QUFDekMsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9CYXNlTW9kZWxcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2NvbnN0cnVjdGlvblwiO1xuZXhwb3J0ICogZnJvbSBcIi4vZGVjb3JhdG9yc1wiO1xuLy8gZXhwb3J0ICogZnJvbSBcIi4vSWRlbnRpZmllZEJhc2VNb2RlbFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vdHlwZXNcIjtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbW9kZWwvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL0Jhc2VNb2RlbFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vY29uc3RydWN0aW9uXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kZWNvcmF0b3JzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi90eXBlc1wiO1xuIl19

package/lib/esm/model/types.d.ts

@@ -1,4 +1,13 @@
 import { CascadeMetadata } from "../repository";
+/**
+ * @description Metadata for model relationships
+ * @summary Type definition for storing metadata about relationships between models
+ * @property {string} class - The name of the related model class
+ * @property {CascadeMetadata} cascade - Configuration for cascade operations (create, update, delete)
+ * @property {boolean} populate - Whether to automatically populate the relationship when retrieving the model
+ * @typedef {Object} RelationsMetadata
+ * @memberOf module:model
+ */
 export type RelationsMetadata = {
     class: string;
     cascade: CascadeMetadata;

package/lib/esm/model/types.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbW9kZWwvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENhc2NhZGVNZXRhZGF0YSB9IGZyb20gXCIuLi9yZXBvc2l0b3J5XCI7XG5cbmV4cG9ydCB0eXBlIFJlbGF0aW9uc01ldGFkYXRhID0ge1xuICBjbGFzczogc3RyaW5nO1xuICBjYXNjYWRlOiBDYXNjYWRlTWV0YWRhdGE7XG4gIHBvcHVsYXRlOiBib29sZWFuO1xufTtcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbW9kZWwvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENhc2NhZGVNZXRhZGF0YSB9IGZyb20gXCIuLi9yZXBvc2l0b3J5XCI7XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIE1ldGFkYXRhIGZvciBtb2RlbCByZWxhdGlvbnNoaXBzXG4gKiBAc3VtbWFyeSBUeXBlIGRlZmluaXRpb24gZm9yIHN0b3JpbmcgbWV0YWRhdGEgYWJvdXQgcmVsYXRpb25zaGlwcyBiZXR3ZWVuIG1vZGVsc1xuICogQHByb3BlcnR5IHtzdHJpbmd9IGNsYXNzIC0gVGhlIG5hbWUgb2YgdGhlIHJlbGF0ZWQgbW9kZWwgY2xhc3NcbiAqIEBwcm9wZXJ0eSB7Q2FzY2FkZU1ldGFkYXRhfSBjYXNjYWRlIC0gQ29uZmlndXJhdGlvbiBmb3IgY2FzY2FkZSBvcGVyYXRpb25zIChjcmVhdGUsIHVwZGF0ZSwgZGVsZXRlKVxuICogQHByb3BlcnR5IHtib29sZWFufSBwb3B1bGF0ZSAtIFdoZXRoZXIgdG8gYXV0b21hdGljYWxseSBwb3B1bGF0ZSB0aGUgcmVsYXRpb25zaGlwIHdoZW4gcmV0cmlldmluZyB0aGUgbW9kZWxcbiAqIEB0eXBlZGVmIHtPYmplY3R9IFJlbGF0aW9uc01ldGFkYXRhXG4gKiBAbWVtYmVyT2YgbW9kdWxlOm1vZGVsXG4gKi9cbmV4cG9ydCB0eXBlIFJlbGF0aW9uc01ldGFkYXRhID0ge1xuICBjbGFzczogc3RyaW5nO1xuICBjYXNjYWRlOiBDYXNjYWRlTWV0YWRhdGE7XG4gIHBvcHVsYXRlOiBib29sZWFuO1xufTtcbiJdfQ==