@decaf-ts/core
Version:
Core persistence module for the decaf framework
97 lines • 12.1 kB
JavaScript
import { Decoration, propMetadata, required, } from "@decaf-ts/decorator-validation";
import { DefaultSequenceOptions, } from "./../interfaces/SequenceOptions.js";
import { DBKeys, InternalError, onCreate, readonly, } from "@decaf-ts/db-decorators";
import { Repository } from "./../repository/Repository.js";
import { index } from "./../model/decorators.js";
import { sequenceNameForModel } from "./utils.js";
import { OrderDirection } from "./../repository/index.js";
/**
* @description Callback function for primary key creation
* @summary Handles the creation of primary key values for models using sequences
* @template M - Type that extends Model
* @template R - Type that extends Repo<M, F, C>
* @template V - Type that extends SequenceOptions
* @template F - Type that extends RepositoryFlags
* @template C - Type that extends Context<F>
* @param {Context<F>} context - The execution context
* @param {V} data - The sequence options
* @param key - The property key to set as primary key
* @param {M} model - The model instance
* @return {Promise<void>} A promise that resolves when the primary key is set
* @function pkOnCreate
* @category Property Decorators
* @mermaid
* sequenceDiagram
* participant Model
* participant pkOnCreate
* participant Adapter
* participant Sequence
*
* Model->>pkOnCreate: Call with model instance
* Note over pkOnCreate: Check if key already exists
* alt Key exists or no type specified
* pkOnCreate-->>Model: Return early
* else Key needs to be created
* pkOnCreate->>pkOnCreate: Generate sequence name if not provided
* pkOnCreate->>Adapter: Request Sequence(data)
* Adapter->>Sequence: Create sequence
* Sequence-->>pkOnCreate: Return sequence
* pkOnCreate->>Sequence: Call next()
* Sequence-->>pkOnCreate: Return next value
* pkOnCreate->>Model: Set primary key value
* end
*/
export async function pkOnCreate(context, data, key, model) {
if (!data.type || model[key]) {
return;
}
const setPrimaryKeyValue = function (target, propertyKey, value) {
Object.defineProperty(target, propertyKey, {
enumerable: true,
writable: false,
configurable: true,
value: value,
});
};
if (!data.name)
data.name = sequenceNameForModel(model, "pk");
let sequence;
try {
sequence = await this.adapter.Sequence(data);
}
catch (e) {
throw new InternalError(`Failed to instantiate Sequence ${data.name}: ${e}`);
}
const next = await sequence.next();
setPrimaryKeyValue(model, key, next);
}
/**
* @description Primary Key Decorator
* @summary Marks a property as the model's primary key with automatic sequence generation
* This decorator combines multiple behaviors: it marks the property as unique, required,
* and ensures the index is created properly according to the provided sequence options.
* @param {Omit<SequenceOptions, "cycle" | "startWith" | "incrementBy">} opts - Options for the sequence generation
* @return {PropertyDecorator} A property decorator that can be applied to model properties
* @function pk
* @category Property Decorators
* @example
* ```typescript
* class User extends BaseModel {
* @pk()
* id!: string;
*
* @required()
* username!: string;
* }
* ```
*/
export function pk(opts = DefaultSequenceOptions) {
opts = Object.assign({}, DefaultSequenceOptions, opts);
const key = Repository.key(DBKeys.ID);
return Decoration.for(key)
.define(index([OrderDirection.ASC, OrderDirection.DSC]), required(), readonly(),
// type([String.name, Number.name, BigInt.name]),
propMetadata(key, opts), onCreate(pkOnCreate, opts))
.apply();
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../../../src/identity/decorators.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EAEV,YAAY,EACZ,QAAQ,GACT,MAAM,gCAAgC,CAAC;AACxC,OAAO,EACL,sBAAsB,GAEvB,2CAAsC;AACvC,OAAO,EACL,MAAM,EACN,aAAa,EACb,QAAQ,EACR,QAAQ,GAET,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAQ,UAAU,EAAE,sCAAiC;AAC5D,OAAO,EAAE,KAAK,EAAE,iCAA4B;AAC5C,OAAO,EAAE,oBAAoB,EAAE,mBAAgB;AAG/C,OAAO,EAAE,cAAc,EAAE,iCAAsB;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,CAAC,KAAK,UAAU,UAAU,CAQ9B,OAAmB,EACnB,IAAO,EACP,GAAY,EACZ,KAAQ;IAER,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;QAC7B,OAAO;IACT,CAAC;IAED,MAAM,kBAAkB,GAAG,UACzB,MAAS,EACT,WAAmB,EACnB,KAA+B;QAE/B,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,WAAW,EAAE;YACzC,UAAU,EAAE,IAAI;YAChB,QAAQ,EAAE,KAAK;YACf,YAAY,EAAE,IAAI;YAClB,KAAK,EAAE,KAAK;SACb,CAAC,CAAC;IACL,CAAC,CAAC;IACF,IAAI,CAAC,IAAI,CAAC,IAAI;QAAE,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IAC9D,IAAI,QAAkB,CAAC;IACvB,IAAI,CAAC;QACH,QAAQ,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IAC/C,CAAC;IAAC,OAAO,CAAM,EAAE,CAAC;QAChB,MAAM,IAAI,aAAa,CACrB,kCAAkC,IAAI,CAAC,IAAI,KAAK,CAAC,EAAE,CACpD,CAAC;IACJ,CAAC;IAED,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC;IACnC,kBAAkB,CAAC,KAAK,EAAE,GAAa,EAAE,IAAI,CAAC,CAAC;AACjD,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,EAAE,CAChB,OAGI,sBAAsB;IAE1B,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,EAAE,EAAE,sBAAsB,EAAE,IAAI,CAAoB,CAAC;IAC1E,MAAM,GAAG,GAAG,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;IACtC,OAAO,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC;SACvB,MAAM,CACL,KAAK,CAAC,CAAC,cAAc,CAAC,GAAG,EAAE,cAAc,CAAC,GAAG,CAAC,CAAC,EAC/C,QAAQ,EAAE,EACV,QAAQ,EAAE;IACV,iDAAiD;IACjD,YAAY,CAAC,GAAG,EAAE,IAAuB,CAAC,EAC1C,QAAQ,CAAC,UAAU,EAAE,IAAuB,CAAC,CAC9C;SACA,KAAK,EAAE,CAAC;AACb,CAAC","sourcesContent":["import {\n  Decoration,\n  Model,\n  propMetadata,\n  required,\n} from \"@decaf-ts/decorator-validation\";\nimport {\n  DefaultSequenceOptions,\n  SequenceOptions,\n} from \"../interfaces/SequenceOptions\";\nimport {\n  DBKeys,\n  InternalError,\n  onCreate,\n  readonly,\n  RepositoryFlags,\n} from \"@decaf-ts/db-decorators\";\nimport { Repo, Repository } from \"../repository/Repository\";\nimport { index } from \"../model/decorators\";\nimport { sequenceNameForModel } from \"./utils\";\nimport { Sequence } from \"../persistence/Sequence\";\nimport { Context } from \"@decaf-ts/db-decorators\";\nimport { OrderDirection } from \"../repository\";\n\n/**\n * @description Callback function for primary key creation\n * @summary Handles the creation of primary key values for models using sequences\n * @template M - Type that extends Model\n * @template R - Type that extends Repo<M, F, C>\n * @template V - Type that extends SequenceOptions\n * @template F - Type that extends RepositoryFlags\n * @template C - Type that extends Context<F>\n * @param {Context<F>} context - The execution context\n * @param {V} data - The sequence options\n * @param key - The property key to set as primary key\n * @param {M} model - The model instance\n * @return {Promise<void>} A promise that resolves when the primary key is set\n * @function pkOnCreate\n * @category Property Decorators\n * @mermaid\n * sequenceDiagram\n *   participant Model\n *   participant pkOnCreate\n *   participant Adapter\n *   participant Sequence\n *\n *   Model->>pkOnCreate: Call with model instance\n *   Note over pkOnCreate: Check if key already exists\n *   alt Key exists or no type specified\n *     pkOnCreate-->>Model: Return early\n *   else Key needs to be created\n *     pkOnCreate->>pkOnCreate: Generate sequence name if not provided\n *     pkOnCreate->>Adapter: Request Sequence(data)\n *     Adapter->>Sequence: Create sequence\n *     Sequence-->>pkOnCreate: Return sequence\n *     pkOnCreate->>Sequence: Call next()\n *     Sequence-->>pkOnCreate: Return next value\n *     pkOnCreate->>Model: Set primary key value\n *   end\n */\nexport async function pkOnCreate<\n  M extends Model,\n  R extends Repo<M, F, C>,\n  V extends SequenceOptions,\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 (!data.type || model[key]) {\n    return;\n  }\n\n  const setPrimaryKeyValue = function <M extends Model>(\n    target: M,\n    propertyKey: string,\n    value: string | number | bigint\n  ) {\n    Object.defineProperty(target, propertyKey, {\n      enumerable: true,\n      writable: false,\n      configurable: true,\n      value: value,\n    });\n  };\n  if (!data.name) data.name = sequenceNameForModel(model, \"pk\");\n  let sequence: Sequence;\n  try {\n    sequence = await this.adapter.Sequence(data);\n  } catch (e: any) {\n    throw new InternalError(\n      `Failed to instantiate Sequence ${data.name}: ${e}`\n    );\n  }\n\n  const next = await sequence.next();\n  setPrimaryKeyValue(model, key as string, next);\n}\n\n/**\n * @description Primary Key Decorator\n * @summary Marks a property as the model's primary key with automatic sequence generation\n * This decorator combines multiple behaviors: it marks the property as unique, required,\n * and ensures the index is created properly according to the provided sequence options.\n * @param {Omit<SequenceOptions, \"cycle\" | \"startWith\" | \"incrementBy\">} opts - Options for the sequence generation\n * @return {PropertyDecorator} A property decorator that can be applied to model properties\n * @function pk\n * @category Property Decorators\n * @example\n * ```typescript\n * class User extends BaseModel {\n *   @pk()\n *   id!: string;\n *\n *   @required()\n *   username!: string;\n * }\n * ```\n */\nexport function pk(\n  opts: Omit<\n    SequenceOptions,\n    \"cycle\" | \"startWith\" | \"incrementBy\"\n  > = DefaultSequenceOptions\n) {\n  opts = Object.assign({}, DefaultSequenceOptions, opts) as SequenceOptions;\n  const key = Repository.key(DBKeys.ID);\n  return Decoration.for(key)\n    .define(\n      index([OrderDirection.ASC, OrderDirection.DSC]),\n      required(),\n      readonly(),\n      // type([String.name, Number.name, BigInt.name]),\n      propMetadata(key, opts as SequenceOptions),\n      onCreate(pkOnCreate, opts as SequenceOptions)\n    )\n    .apply();\n}\n"]}