@decaf-ts/db-decorators
Version:
Agnostic database decorators and repository
192 lines • 25.2 kB
JavaScript
import "./validation.js";
import { date, Decoration, propMetadata, required, type, Validation, } from "@decaf-ts/decorator-validation";
import { DBKeys, DEFAULT_TIMESTAMP_FORMAT } from "./../model/constants.js";
import { DEFAULT_ERROR_MESSAGES } from "./constants.js";
import { DBOperations, OperationKeys } from "./../operations/constants.js";
import { after, on, onCreateUpdate } from "./../operations/decorators.js";
import { SerializationError } from "./../repository/errors.js";
import { apply, metadata } from "@decaf-ts/reflection";
import { Repository } from "./../repository/index.js";
/**
* @description Prevents a property from being modified after initial creation.
* @summary Marks the property as readonly, causing validation errors if attempts are made to modify it during updates.
* @param {string} [message] - The error message to display when validation fails. Defaults to {@link DEFAULT_ERROR_MESSAGES.READONLY.INVALID}
* @return {PropertyDecorator} A decorator function that can be applied to class properties
* @function readonly
* @category Property Decorators
*/
export function readonly(message = DEFAULT_ERROR_MESSAGES.READONLY.INVALID) {
const key = Validation.updateKey(DBKeys.READONLY);
return Decoration.for(key)
.define(propMetadata(key, {
message: message,
}))
.apply();
}
/**
* @description Handler function that sets a timestamp property to the current timestamp.
* @summary Updates a model property with the current timestamp from the repository context.
* @template M - The model type extending Model
* @template R - The repository type extending IRepository
* @template V - The data type for the operation
* @template F - The repository flags type
* @template C - The context type
* @param {C} context - The repository context containing the current timestamp
* @param {V} data - The data being processed
* @param key - The property key to update
* @param {M} model - The model instance being updated
* @return {Promise<void>} A promise that resolves when the timestamp has been set
* @function timestampHandler
* @memberOf module:db-decorators
*/
export async function timestampHandler(context, data, key, model) {
model[key] = context.timestamp;
}
/**
* @description Automatically manages timestamp properties for tracking creation and update times.
* @summary Marks the property as a timestamp, making it required and ensuring it's a valid date. The property will be automatically updated with the current timestamp during specified operations.
*
* Date Format:
*
* <pre>
* Using similar formatting as Moment.js, Class DateTimeFormatter (Java), and Class SimpleDateFormat (Java),
* I implemented a comprehensive solution formatDate(date, patternStr) where the code is easy to read and modify.
* You can display date, time, AM/PM, etc.
*
* Date and Time Patterns
* yy = 2-digit year; yyyy = full year
* M = digit month; MM = 2-digit month; MMM = short month name; MMMM = full month name
* EEEE = full weekday name; EEE = short weekday name
* d = digit day; dd = 2-digit day
* h = hours am/pm; hh = 2-digit hours am/pm; H = hours; HH = 2-digit hours
* m = minutes; mm = 2-digit minutes; aaa = AM/PM
* s = seconds; ss = 2-digit seconds
* S = miliseconds
* </pre>
*
* @param {OperationKeys[]} operation - The operations to act on. Defaults to {@link DBOperations.CREATE_UPDATE}
* @param {string} [format] - The timestamp format. Defaults to {@link DEFAULT_TIMESTAMP_FORMAT}
* @return {PropertyDecorator} A decorator function that can be applied to class properties
* @function timestamp
* @category Property Decorators
* @mermaid
* sequenceDiagram
* participant C as Client
* participant M as Model
* participant T as TimestampDecorator
* participant V as Validator
*
* C->>M: Create/Update model
* M->>T: Process timestamp property
* T->>M: Apply required validation
* T->>M: Apply date format validation
*
* alt Update operation
* T->>V: Register timestamp validator
* V->>M: Validate timestamp is newer
* end
*
* T->>M: Set current timestamp
* M->>C: Return updated model
*/
export function timestamp(operation = DBOperations.CREATE_UPDATE, format = DEFAULT_TIMESTAMP_FORMAT) {
const key = Validation.updateKey(DBKeys.TIMESTAMP);
const decorators = [
date(format, DEFAULT_ERROR_MESSAGES.TIMESTAMP.DATE),
required(DEFAULT_ERROR_MESSAGES.TIMESTAMP.REQUIRED),
on(operation, timestampHandler),
];
if (operation.indexOf(OperationKeys.UPDATE) !== -1)
decorators.push(propMetadata(Validation.updateKey(DBKeys.TIMESTAMP), {
message: DEFAULT_ERROR_MESSAGES.TIMESTAMP.INVALID,
}));
return Decoration.for(key)
.define(...decorators)
.apply();
}
/**
* @description Handler function that serializes a property to JSON string during create and update operations.
* @summary Converts a complex object property to a JSON string before storing it in the database.
* @template M - The model type extending Model
* @template R - The repository type extending IRepository
* @template V - The data type for the operation
* @template F - The repository flags type
* @template C - The context type
* @param {C} context - The repository context
* @param {V} data - The data being processed
* @param key - The property key to serialize
* @param {M} model - The model instance being processed
* @return {Promise<void>} A promise that resolves when the property has been serialized
* @function serializeOnCreateUpdate
* @memberOf module:db-decorators
*/
export async function serializeOnCreateUpdate(context, data, key, model) {
if (!model[key])
return;
try {
model[key] = JSON.stringify(model[key]);
// eslint-disable-next-line @typescript-eslint/no-unused-vars
}
catch (e) {
throw new SerializationError(`Failed to serialize ${key.toString()} property of model ${model.constructor.name}: e`);
}
}
/**
* @description Handler function that deserializes a property from JSON string after database operations.
* @summary Converts a JSON string property back to its original complex object form after retrieving it from the database.
* @template M - The model type extending Model
* @template R - The repository type extending IRepository
* @template V - The data type for the operation
* @template F - The repository flags type
* @template C - The context type
* @param {C} context - The repository context
* @param {V} data - The data being processed
* @param key - The property key to deserialize
* @param {M} model - The model instance being processed
* @return {Promise<void>} A promise that resolves when the property has been deserialized
* @function serializeAfterAll
* @memberOf module:db-decorators
*/
export async function serializeAfterAll(context, data, key, model) {
if (!model[key])
return;
if (typeof model[key] !== "string")
return;
try {
model[key] = JSON.parse(model[key]);
}
catch (e) {
throw new SerializationError(`Failed to deserialize ${key.toString()} property of model ${model.constructor.name}: ${e}`);
}
}
/**
* @description Enables automatic JSON serialization and deserialization for complex object properties.
* @summary Decorator that automatically converts complex objects to JSON strings before storing in the database and back to objects when retrieving them.
* @return {PropertyDecorator} A decorator function that can be applied to class properties
* @function serialize
* @category Property Decorators
* @mermaid
* sequenceDiagram
* participant C as Client
* participant M as Model
* participant S as SerializeDecorator
* participant DB as Database
*
* Note over C,DB: Create/Update Flow
* C->>M: Set complex object property
* M->>S: Process property (create/update)
* S->>M: Convert to JSON string
* M->>DB: Store serialized data
*
* Note over C,DB: Retrieval Flow
* C->>M: Request model
* M->>DB: Fetch data
* DB->>M: Return with serialized property
* M->>S: Process property (after all ops)
* S->>M: Parse JSON back to object
* M->>C: Return model with deserialized property
*/
export function serialize() {
return apply(onCreateUpdate(serializeOnCreateUpdate), after(DBOperations.ALL, serializeAfterAll), type([String.name, Object.name]), metadata(Repository.key(DBKeys.SERIALIZE), {}));
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../../../src/validation/decorators.ts"],"names":[],"mappings":"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","sourcesContent":["import \"./validation\";\nimport {\n  date,\n  Decoration,\n  Model,\n  propMetadata,\n  required,\n  type,\n  Validation,\n} from \"@decaf-ts/decorator-validation\";\nimport { DBKeys, DEFAULT_TIMESTAMP_FORMAT } from \"../model/constants\";\nimport { DEFAULT_ERROR_MESSAGES } from \"./constants\";\nimport { DBOperations, OperationKeys } from \"../operations/constants\";\nimport { after, on, onCreateUpdate } from \"../operations/decorators\";\nimport { IRepository } from \"../interfaces/IRepository\";\nimport { SerializationError } from \"../repository/errors\";\nimport { apply, metadata } from \"@decaf-ts/reflection\";\nimport { Repository } from \"../repository\";\nimport { Context } from \"../repository/Context\";\nimport { RepositoryFlags } from \"../repository/types\";\n\n/**\n * @description Prevents a property from being modified after initial creation.\n * @summary Marks the property as readonly, causing validation errors if attempts are made to modify it during updates.\n * @param {string} [message] - The error message to display when validation fails. Defaults to {@link DEFAULT_ERROR_MESSAGES.READONLY.INVALID}\n * @return {PropertyDecorator} A decorator function that can be applied to class properties\n * @function readonly\n * @category Property Decorators\n */\nexport function readonly(\n  message: string = DEFAULT_ERROR_MESSAGES.READONLY.INVALID\n) {\n  const key = Validation.updateKey(DBKeys.READONLY);\n  return Decoration.for(key)\n    .define(\n      propMetadata(key, {\n        message: message,\n      })\n    )\n    .apply();\n}\n\n/**\n * @description Handler function that sets a timestamp property to the current timestamp.\n * @summary Updates a model property with the current timestamp from the repository context.\n * @template M - The model type extending Model\n * @template R - The repository type extending IRepository\n * @template V - The data type for the operation\n * @template F - The repository flags type\n * @template C - The context type\n * @param {C} context - The repository context containing the current timestamp\n * @param {V} data - The data being processed\n * @param key - The property key to update\n * @param {M} model - The model instance being updated\n * @return {Promise<void>} A promise that resolves when the timestamp has been set\n * @function timestampHandler\n * @memberOf module:db-decorators\n */\nexport async function timestampHandler<\n  M extends Model,\n  R extends IRepository<M, F, C>,\n  V,\n  F extends RepositoryFlags = RepositoryFlags,\n  C extends Context<F> = Context<F>,\n>(this: R, context: C, data: V, key: keyof M, model: M): Promise<void> {\n  (model as any)[key] = context.timestamp;\n}\n\n/**\n * @description Automatically manages timestamp properties for tracking creation and update times.\n * @summary Marks the property as a timestamp, making it required and ensuring it's a valid date. The property will be automatically updated with the current timestamp during specified operations.\n *\n * Date Format:\n *\n * <pre>\n *      Using similar formatting as Moment.js, Class DateTimeFormatter (Java), and Class SimpleDateFormat (Java),\n *      I implemented a comprehensive solution formatDate(date, patternStr) where the code is easy to read and modify.\n *      You can display date, time, AM/PM, etc.\n *\n *      Date and Time Patterns\n *      yy = 2-digit year; yyyy = full year\n *      M = digit month; MM = 2-digit month; MMM = short month name; MMMM = full month name\n *      EEEE = full weekday name; EEE = short weekday name\n *      d = digit day; dd = 2-digit day\n *      h = hours am/pm; hh = 2-digit hours am/pm; H = hours; HH = 2-digit hours\n *      m = minutes; mm = 2-digit minutes; aaa = AM/PM\n *      s = seconds; ss = 2-digit seconds\n *      S = miliseconds\n * </pre>\n *\n * @param {OperationKeys[]} operation - The operations to act on. Defaults to {@link DBOperations.CREATE_UPDATE}\n * @param {string} [format] - The timestamp format. Defaults to {@link DEFAULT_TIMESTAMP_FORMAT}\n * @return {PropertyDecorator} A decorator function that can be applied to class properties\n * @function timestamp\n * @category Property Decorators\n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant M as Model\n *   participant T as TimestampDecorator\n *   participant V as Validator\n *\n *   C->>M: Create/Update model\n *   M->>T: Process timestamp property\n *   T->>M: Apply required validation\n *   T->>M: Apply date format validation\n *\n *   alt Update operation\n *     T->>V: Register timestamp validator\n *     V->>M: Validate timestamp is newer\n *   end\n *\n *   T->>M: Set current timestamp\n *   M->>C: Return updated model\n */\nexport function timestamp(\n  operation: OperationKeys[] = DBOperations.CREATE_UPDATE as unknown as OperationKeys[],\n  format: string = DEFAULT_TIMESTAMP_FORMAT\n) {\n  const key = Validation.updateKey(DBKeys.TIMESTAMP);\n\n  const decorators: any[] = [\n    date(format, DEFAULT_ERROR_MESSAGES.TIMESTAMP.DATE),\n    required(DEFAULT_ERROR_MESSAGES.TIMESTAMP.REQUIRED),\n    on(operation, timestampHandler),\n  ];\n\n  if (operation.indexOf(OperationKeys.UPDATE) !== -1)\n    decorators.push(\n      propMetadata(Validation.updateKey(DBKeys.TIMESTAMP), {\n        message: DEFAULT_ERROR_MESSAGES.TIMESTAMP.INVALID,\n      })\n    );\n  return Decoration.for(key)\n    .define(...decorators)\n    .apply();\n}\n\n/**\n * @description Handler function that serializes a property to JSON string during create and update operations.\n * @summary Converts a complex object property to a JSON string before storing it in the database.\n * @template M - The model type extending Model\n * @template R - The repository type extending IRepository\n * @template V - The data type for the operation\n * @template F - The repository flags type\n * @template C - The context type\n * @param {C} context - The repository context\n * @param {V} data - The data being processed\n * @param key - The property key to serialize\n * @param {M} model - The model instance being processed\n * @return {Promise<void>} A promise that resolves when the property has been serialized\n * @function serializeOnCreateUpdate\n * @memberOf module:db-decorators\n */\nexport async function serializeOnCreateUpdate<\n  M extends Model,\n  R extends IRepository<M, F, C>,\n  V,\n  F extends RepositoryFlags = RepositoryFlags,\n  C extends Context<F> = Context<F>,\n>(this: R, context: C, data: V, key: keyof M, model: M): Promise<void> {\n  if (!model[key]) return;\n  try {\n    model[key] = JSON.stringify(model[key]) as M[keyof M];\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  } catch (e: unknown) {\n    throw new SerializationError(\n      `Failed to serialize ${key.toString()} property of model ${model.constructor.name}: e`\n    );\n  }\n}\n\n/**\n * @description Handler function that deserializes a property from JSON string after database operations.\n * @summary Converts a JSON string property back to its original complex object form after retrieving it from the database.\n * @template M - The model type extending Model\n * @template R - The repository type extending IRepository\n * @template V - The data type for the operation\n * @template F - The repository flags type\n * @template C - The context type\n * @param {C} context - The repository context\n * @param {V} data - The data being processed\n * @param key - The property key to deserialize\n * @param {M} model - The model instance being processed\n * @return {Promise<void>} A promise that resolves when the property has been deserialized\n * @function serializeAfterAll\n * @memberOf module:db-decorators\n */\nexport async function serializeAfterAll<\n  M extends Model,\n  R extends IRepository<M, F, C>,\n  V,\n  F extends RepositoryFlags = RepositoryFlags,\n  C extends Context<F> = Context<F>,\n>(this: R, context: C, data: V, key: keyof M, model: M): Promise<void> {\n  if (!model[key]) return;\n  if (typeof model[key] !== \"string\") return;\n\n  try {\n    model[key] = JSON.parse(model[key]);\n  } catch (e: unknown) {\n    throw new SerializationError(\n      `Failed to deserialize ${key.toString()} property of model ${model.constructor.name}: ${e}`\n    );\n  }\n}\n\n/**\n * @description Enables automatic JSON serialization and deserialization for complex object properties.\n * @summary Decorator that automatically converts complex objects to JSON strings before storing in the database and back to objects when retrieving them.\n * @return {PropertyDecorator} A decorator function that can be applied to class properties\n * @function serialize\n * @category Property Decorators\n * @mermaid\n * sequenceDiagram\n *   participant C as Client\n *   participant M as Model\n *   participant S as SerializeDecorator\n *   participant DB as Database\n *\n *   Note over C,DB: Create/Update Flow\n *   C->>M: Set complex object property\n *   M->>S: Process property (create/update)\n *   S->>M: Convert to JSON string\n *   M->>DB: Store serialized data\n *\n *   Note over C,DB: Retrieval Flow\n *   C->>M: Request model\n *   M->>DB: Fetch data\n *   DB->>M: Return with serialized property\n *   M->>S: Process property (after all ops)\n *   S->>M: Parse JSON back to object\n *   M->>C: Return model with deserialized property\n */\nexport function serialize() {\n  return apply(\n    onCreateUpdate(serializeOnCreateUpdate),\n    after(DBOperations.ALL, serializeAfterAll),\n    type([String.name, Object.name]),\n    metadata(Repository.key(DBKeys.SERIALIZE), {})\n  );\n}\n"]}