@opra/common 0.23.2 → 0.24.1

package/browser.js

@@ -14,7 +14,9 @@ var __export = (target, all) => {
 import "reflect-metadata";
 
 // ../../build/common/esm/document/constants.js
-var METADATA_KEY = Symbol.for("opra.metadata");
+var DATATYPE_METADATA = Symbol("DATATYPE_METADATA");
+var RESOURCE_METADATA = Symbol("RESOURCE_METADATA");
+var DECORATOR = Symbol("DECORATOR");
 var NAMESPACE_PATTERN = /([A-Z$_]\w+)(?::.+)?/i;
 var TYPENAME_PATTERN = /^(.*)Type(\d*)$/;
 
@@ -122,9 +124,9 @@ function mergePrototype(targetProto, baseProto, filter) {
   }
 }
 __name(mergePrototype, "mergePrototype");
-function inheritPropertyInitializers(target, sourceClass, isPropertyInherited = (key) => true) {
+function inheritPropertyInitializers(target, clazz, isPropertyInherited = (key) => true) {
   try {
-    const tempInstance = new sourceClass();
+    const tempInstance = new clazz();
     const propertyNames = Object.getOwnPropertyNames(tempInstance);
     propertyNames.filter((propertyName) => typeof tempInstance[propertyName] !== "undefined" && typeof target[propertyName] === "undefined").filter((propertyName) => isPropertyInherited(propertyName)).forEach((propertyName) => {
       target[propertyName] = tempInstance[propertyName];
@@ -854,7 +856,7 @@ var ResourceNotFoundError = class extends OpraException {
   }
   constructor(resource, keyValue, cause) {
     super({
-      message: translate(`error:RESOURCE_NOT_FOUND`, { resource: resource + (keyValue ? "@" + keyValue : "") }, `The resource '{{resource}}' not found`),
+      message: translate(`error:RESOURCE_NOT_FOUND`, `Resource not found`),
       severity: "error",
       code: "RESOURCE_NOT_FOUND",
       details: {
@@ -895,9 +897,9 @@ __export(opra_schema_ns_exports, {
   isDataType: () => isDataType,
   isEnumType: () => isEnumType,
   isMappedType: () => isMappedType,
-  isResource: () => isResource,
   isSimpleType: () => isSimpleType,
   isSingleton: () => isSingleton,
+  isSource: () => isSource,
   isStorage: () => isStorage,
   isUnionType: () => isUnionType
 });
@@ -984,10 +986,10 @@ function isEnumType(obj) {
   return obj && typeof obj === "object" && obj.kind === EnumType.Kind;
 }
 __name(isEnumType, "isEnumType");
-function isResource(obj) {
-  return obj && typeof obj === "object" && (obj.kind === Container.Kind || obj.kind === Collection.Kind || obj.kind === Singleton.Kind);
+function isSource(obj) {
+  return obj && typeof obj === "object" && (obj.kind === Container.Kind || obj.kind === Collection.Kind || obj.kind === Singleton.Kind || obj.kind === Storage.Kind);
 }
-__name(isResource, "isResource");
+__name(isSource, "isSource");
 function isCollection(obj) {
   return obj && typeof obj === "object" && obj.kind === Collection.Kind;
 }
@@ -1090,18 +1092,18 @@ var EnumType2 = /* @__PURE__ */ __name(function(...args) {
     merge2(this, new EnumTypeClass(document, init), { descriptor: true });
     return;
   }
-  const [source, options] = args;
-  const values = Array.isArray(source) ? source.reduce((obj, v) => {
+  const [enumSource, options] = args;
+  const values = Array.isArray(enumSource) ? enumSource.reduce((obj, v) => {
     obj[v] = v;
     return obj;
-  }, {}) : source;
+  }, {}) : enumSource;
   const metadata = {
     kind: opra_schema_ns_exports.EnumType.Kind,
     values
   };
   if (options)
     Object.assign(metadata, omit(options, ["kind", "values"]));
-  Reflect.defineMetadata(METADATA_KEY, metadata, source);
+  Reflect.defineMetadata(DATATYPE_METADATA, metadata, enumSource);
   return values;
 }, "EnumType");
 EnumType2.prototype = EnumTypeClass.prototype;
@@ -1113,7 +1115,7 @@ var ApiField = /* @__PURE__ */ __name(function(...args) {
     return function(target, propertyKey) {
       if (typeof propertyKey !== "string")
         throw new TypeError(`Symbol properties can't be used as a field`);
-      const metadata = Reflect.getOwnMetadata(METADATA_KEY, target.constructor) || {};
+      const metadata = Reflect.getOwnMetadata(DATATYPE_METADATA, target.constructor) || {};
       metadata.kind = opra_schema_ns_exports.ComplexType.Kind;
       metadata.fields = metadata.fields || {};
       const designType = Reflect.getMetadata("design:type", target, propertyKey);
@@ -1136,13 +1138,13 @@ var ApiField = /* @__PURE__ */ __name(function(...args) {
           EnumType2(enumObj);
           elemMeta.enum = enumObj;
         } else {
-          const m = Reflect.getOwnMetadata(METADATA_KEY, options?.enum);
+          const m = Reflect.getOwnMetadata(DATATYPE_METADATA, options?.enum);
           if (!opra_schema_ns_exports.isEnumType(m))
             throw new TypeError(`Invalid "enum" value. Did you forget to set metadata using EnumType() method?`);
           elemMeta.enum = options.enum;
         }
       }
-      Reflect.defineMetadata(METADATA_KEY, omitUndefined(metadata), target.constructor);
+      Reflect.defineMetadata(DATATYPE_METADATA, omitUndefined(metadata), target.constructor);
     };
   }
   const [owner, init] = args;
@@ -1325,10 +1327,10 @@ var ComplexType2 = /* @__PURE__ */ __name(function(...args) {
   const [options] = args;
   return function(target) {
     const name = options?.name || target.name.match(TYPENAME_PATTERN)?.[1] || target.name;
-    let metadata = Reflect.getOwnMetadata(METADATA_KEY, target);
+    let metadata = Reflect.getOwnMetadata(DATATYPE_METADATA, target);
     if (!metadata) {
       metadata = {};
-      Reflect.defineMetadata(METADATA_KEY, metadata, target);
+      Reflect.defineMetadata(DATATYPE_METADATA, metadata, target);
     }
     metadata.kind = opra_schema_ns_exports.ComplexType.Kind;
     metadata.name = name;
@@ -1619,12 +1621,12 @@ var SimpleType2 = /* @__PURE__ */ __name(function(...args) {
   return function(target) {
     let name = options?.name || target.name.match(TYPENAME_PATTERN)?.[1] || target.name;
     name = name.charAt(0).toLowerCase() + name.substring(1);
-    const metadata = Reflect.getOwnMetadata(METADATA_KEY, target) || {};
+    const metadata = Reflect.getOwnMetadata(DATATYPE_METADATA, target) || {};
     metadata.kind = opra_schema_ns_exports.SimpleType.Kind;
     metadata.name = name;
     if (options)
       Object.assign(metadata, omit3(options, ["kind", "name"]));
-    Reflect.defineMetadata(METADATA_KEY, metadata, target);
+    Reflect.defineMetadata(DATATYPE_METADATA, metadata, target);
   };
 }, "SimpleType");
 SimpleType2.prototype = SimpleTypeClass.prototype;
@@ -1880,10 +1882,10 @@ async function createDocument(init, options) {
     this.curPath.push("resources");
     if (Array.isArray(init.resources)) {
       for (const res of init.resources)
-        await this.importResourceClass(res);
+        await this.importSourceClass(res);
     } else
-      this.resourceQueue.setAll(init.resources);
-    await this.processResourceQueue();
+      this.sourceQueue.setAll(init.resources);
+    await this.processSourceQueue();
     this.curPath.pop();
   }
   this.document.types.sort();
@@ -1941,14 +1943,14 @@ __name(createBuiltinTypeDocument, "createBuiltinTypeDocument");
 // ../../build/common/esm/document/factory/import-resource-class.js
 import "reflect-metadata";
 async function importResourceClass(thunk) {
-  const { document, resourceQueue, cache } = this;
+  const { document, sourceQueue, cache } = this;
   const controller = await resolveThunk(thunk);
   const cached = cache.get(controller);
   if (cached)
     return cached;
   const ctor = typeof thunk === "function" ? thunk : Object.getPrototypeOf(thunk).constructor;
-  let metadata = Reflect.getMetadata(METADATA_KEY, ctor);
-  if (!metadata && opra_schema_ns_exports.isResource(metadata))
+  let metadata = Reflect.getMetadata(RESOURCE_METADATA, ctor);
+  if (!metadata && opra_schema_ns_exports.isSource(metadata))
     throw new TypeError(`Class "${ctor.name}" doesn't have a valid Resource metadata`);
   metadata = cloneObject(metadata);
   const schema = cloneObject(metadata);
@@ -1968,7 +1970,7 @@ async function importResourceClass(thunk) {
     await this.extractSingletonSchema(schema, ctor, metadata, controller);
   if (opra_schema_ns_exports.isCollection(schema))
     await this.extractCollectionSchema(schema, ctor, metadata, controller);
-  resourceQueue.set(metadata.name, schema);
+  sourceQueue.set(metadata.name, schema);
 }
 __name(importResourceClass, "importResourceClass");
 async function extractSingletonSchema(target, ctor, metadata, controller) {
@@ -1989,7 +1991,7 @@ async function importTypeClass(typeThunk) {
   const dt = document.getDataType(thunk, true);
   if (dt && dt.name)
     return dt.name;
-  const metadata = Reflect.getMetadata(METADATA_KEY, thunk);
+  const metadata = Reflect.getMetadata(DATATYPE_METADATA, thunk);
   if (!(metadata && opra_schema_ns_exports.isDataType(metadata))) {
     if (isConstructor(thunk))
       throw new TypeError(`Class "${thunk.name}" doesn't have a valid DataType metadata`);
@@ -2021,7 +2023,7 @@ async function importTypeClass(typeThunk) {
   const enumObject = thunk;
   if (opra_schema_ns_exports.isEnumType(schema)) {
     let baseType;
-    if (metadata.base && Reflect.hasMetadata(METADATA_KEY, metadata.base)) {
+    if (metadata.base && Reflect.hasMetadata(DATATYPE_METADATA, metadata.base)) {
       baseType = await this.importTypeClass(metadata.base);
     }
     schema.base = baseType;
@@ -2033,7 +2035,7 @@ async function importTypeClass(typeThunk) {
 __name(importTypeClass, "importTypeClass");
 async function extractSimpleTypeSchema(target, ctor, metadata) {
   const baseClass = Object.getPrototypeOf(ctor.prototype).constructor;
-  if (Reflect.hasMetadata(METADATA_KEY, baseClass))
+  if (Reflect.hasMetadata(DATATYPE_METADATA, baseClass))
     target.base = await this.importTypeClass(baseClass);
   if (typeof ctor.prototype.decode === "function")
     target.decoder = validator(metadata.name, ctor.prototype.decode);
@@ -2043,7 +2045,7 @@ async function extractSimpleTypeSchema(target, ctor, metadata) {
 __name(extractSimpleTypeSchema, "extractSimpleTypeSchema");
 async function extractComplexTypeSchema(target, ctor, metadata) {
   const baseClass = Object.getPrototypeOf(ctor.prototype).constructor;
-  if (Reflect.hasMetadata(METADATA_KEY, baseClass))
+  if (Reflect.hasMetadata(DATATYPE_METADATA, baseClass))
     target.base = await this.importTypeClass(baseClass);
   target.ctor = target.ctor || ctor;
   if (metadata.fields) {
@@ -2100,8 +2102,9 @@ async function extractFieldSchema(target, ctor, metadata, name) {
 __name(extractFieldSchema, "extractFieldSchema");
 
 // ../../build/common/esm/document/resource/collection.js
-import omit4 from "lodash.omit";
-import merge7 from "putil-merge";
+import merge8 from "putil-merge";
+
+// ../../build/common/esm/document/resource/collection-class.js
 import * as vg4 from "valgen";
 
 // ../../build/common/esm/filter/opra-filter.ns.js
@@ -9659,32 +9662,32 @@ var MappedType2 = /* @__PURE__ */ __name(function(...args) {
     merge5(this, new MappedTypeClass(document, init), { descriptor: true });
     return;
   }
-  const [source, options] = args;
+  const [mappedSource, options] = args;
   const isInheritedPredicate = getIsInheritedPredicateFn(options.pick, options.omit);
   class MappedClass {
     static {
       __name(this, "MappedClass");
     }
     constructor() {
-      inheritPropertyInitializers(this, source, isInheritedPredicate);
+      inheritPropertyInitializers(this, mappedSource, isInheritedPredicate);
     }
   }
-  mergePrototype(MappedClass.prototype, source.prototype);
-  const m = Reflect.getOwnMetadata(METADATA_KEY, source);
+  mergePrototype(MappedClass.prototype, mappedSource.prototype);
+  const m = Reflect.getOwnMetadata(DATATYPE_METADATA, mappedSource);
   if (!m)
-    throw new TypeError(`Class "${source}" doesn't have datatype metadata information`);
+    throw new TypeError(`Class "${mappedSource}" doesn't have datatype metadata information`);
   if (!(m.kind === opra_schema_ns_exports.ComplexType.Kind))
-    throw new TypeError(`Class "${source}" is not a ${opra_schema_ns_exports.ComplexType.Kind}`);
+    throw new TypeError(`Class "${mappedSource}" is not a ${opra_schema_ns_exports.ComplexType.Kind}`);
   const metadata = {
     kind: "MappedType",
-    type: source
+    type: mappedSource
   };
   if (options.pick)
     metadata.pick = options.pick;
   if (options.omit)
     metadata.omit = options.omit;
-  Reflect.defineMetadata(METADATA_KEY, metadata, MappedClass);
-  MappedType2._applyMixin(MappedClass, source, {
+  Reflect.defineMetadata(DATATYPE_METADATA, metadata, MappedClass);
+  MappedType2._applyMixin(MappedClass, mappedSource, {
     ...options,
     isInheritedPredicate
   });
@@ -9768,9 +9771,9 @@ var UnionType2 = /* @__PURE__ */ __name(function(...args) {
     kind: opra_schema_ns_exports.UnionType.Kind,
     types: []
   };
-  Reflect.defineMetadata(METADATA_KEY, metadata, UnionClass);
+  Reflect.defineMetadata(DATATYPE_METADATA, metadata, UnionClass);
   for (const c of clasRefs) {
-    const itemMeta = Reflect.getMetadata(METADATA_KEY, c);
+    const itemMeta = Reflect.getMetadata(DATATYPE_METADATA, c);
     if (!(itemMeta && (itemMeta.kind === opra_schema_ns_exports.ComplexType.Kind || itemMeta.kind === opra_schema_ns_exports.UnionType.Kind || itemMeta.kind === opra_schema_ns_exports.MappedType.Kind)))
       throw new TypeError(`Class "${c.name}" is not a ${opra_schema_ns_exports.ComplexType.Kind}, ${opra_schema_ns_exports.UnionType.Kind} or ${opra_schema_ns_exports.MappedType.Kind}`);
     metadata.types.push(c);
@@ -9784,17 +9787,17 @@ UnionType2._applyMixin = () => void 0;
 
 // ../../build/common/esm/document/utils/generate-codec.js
 function generateCodec(type, codec, options) {
-  return _generateDecoder(type, codec, options);
+  return _generateCodec(type, codec, options);
 }
 __name(generateCodec, "generateCodec");
-function _generateDecoder(type, codec, options) {
+function _generateCodec(type, codec, options) {
   const schema = {};
   for (const f of type.fields.values()) {
     let fn;
     if (f.type instanceof SimpleType2 || f.type instanceof EnumType2) {
       fn = f.type[codec];
     } else if (f.type instanceof ComplexType2 || f.type instanceof MappedType2 || f.type instanceof UnionType2) {
-      fn = _generateDecoder(f.type, codec, options);
+      fn = _generateCodec(f.type, codec, options);
     }
     if (!fn)
       throw new TypeError(`Can't generate codec for (${f.type})`);
@@ -9809,7 +9812,20 @@ function _generateDecoder(type, codec, options) {
     caseInSensitive: true
   });
 }
-__name(_generateDecoder, "_generateDecoder");
+__name(_generateCodec, "_generateCodec");
+
+// ../../build/common/esm/document/resource/action.js
+var Action = class {
+  static {
+    __name(this, "Action");
+  }
+  constructor(init) {
+    this.name = init.name;
+  }
+  exportSchema() {
+    return {};
+  }
+};
 
 // ../../build/common/esm/document/resource/resource.js
 var Resource = class {
@@ -9817,16 +9833,31 @@ var Resource = class {
     __name(this, "Resource");
   }
   constructor(document, init) {
+    this.actions = {};
     this.document = document;
     this.name = init.name;
     this.description = init.description;
     this.controller = init.controller;
+    if (init.actions) {
+      for (const [name, meta] of Object.entries(init.actions)) {
+        this.actions[name.toLowerCase()] = new Action({ ...meta, name });
+      }
+    }
   }
   exportSchema() {
-    return omitUndefined({
+    const schema = omitUndefined({
       kind: this.kind,
       description: this.description
     });
+    const actions = {};
+    let i = 0;
+    for (const action of Object.values(this.actions)) {
+      actions[action.name] = action.exportSchema();
+      i++;
+    }
+    if (i)
+      schema.actions = actions;
+    return schema;
   }
   toString() {
     return `[${Object.getPrototypeOf(this).constructor.name} ${this.name || "#anonymous"}]`;
@@ -9836,9 +9867,7 @@ var Resource = class {
   }
 };
 
-// ../../build/common/esm/document/resource/collection.js
-var NESTJS_INJECTABLE_WATERMARK = "__injectable__";
-var NAME_PATTERN = /^(.*)(Resource|Collection)$/;
+// ../../build/common/esm/document/resource/collection-class.js
 var CollectionClass = class extends Resource {
   static {
     __name(this, "CollectionClass");
@@ -9861,13 +9890,14 @@ var CollectionClass = class extends Resource {
     });
   }
   exportSchema() {
-    const out = Resource.prototype.exportSchema.call(this);
-    Object.assign(out, omitUndefined({
-      type: this.type.name,
-      operations: this.operations,
-      primaryKey: this.primaryKey
-    }));
-    return out;
+    return {
+      ...super.exportSchema(),
+      ...omitUndefined({
+        type: this.type.name || "object",
+        operations: this.operations,
+        primaryKey: this.primaryKey
+      })
+    };
   }
   parseKeyValue(value) {
     if (!this.primaryKey?.length)
@@ -9963,84 +9993,121 @@ var CollectionClass = class extends Resource {
     }
     return ast;
   }
-  getDecoder(operation) {
-    let decoder = this._decoders[operation];
+  getDecoder(endpoint) {
+    let decoder = this._decoders[endpoint];
     if (decoder)
       return decoder;
     const options = {
-      partial: operation !== "create"
+      partial: endpoint !== "create"
     };
-    if (operation !== "create")
+    if (endpoint !== "create")
       options.omit = [...this.primaryKey];
     decoder = generateCodec(this.type, "decode", options);
-    this._decoders[operation] = decoder;
+    this._decoders[endpoint] = decoder;
     return decoder;
   }
-  getEncoder(operation) {
-    let encoder = this._encoders[operation];
+  getEncoder(endpoint) {
+    let encoder = this._encoders[endpoint];
     if (encoder)
       return encoder;
     const options = {
       partial: true
     };
     encoder = generateCodec(this.type, "encode", options);
-    if (operation === "findMany")
+    if (endpoint === "findMany")
       return vg4.isArray(encoder);
-    this._encoders[operation] = encoder;
+    this._encoders[endpoint] = encoder;
     return encoder;
   }
 };
-var Collection2 = /* @__PURE__ */ __name(function(...args) {
-  if (!this) {
-    const [type, options] = args;
-    return function(target) {
-      const name = options?.name || target.name.match(NAME_PATTERN)?.[1] || target.name;
-      const metadata = Reflect.getOwnMetadata(METADATA_KEY, target) || {};
-      const baseMetadata = Reflect.getOwnMetadata(METADATA_KEY, Object.getPrototypeOf(target));
-      if (baseMetadata) {
-        merge7(metadata, baseMetadata, { deep: true });
-      }
-      metadata.kind = opra_schema_ns_exports.Collection.Kind;
-      metadata.name = name;
-      metadata.type = type;
-      const m = Reflect.getMetadata(METADATA_KEY, target);
-      if (m && metadata !== m)
-        Object.assign(metadata, omit4(m), Object.keys(metadata));
-      if (options)
-        Object.assign(metadata, omit4(options, ["kind", "name", "type", "controller"]));
-      Reflect.defineMetadata(METADATA_KEY, metadata, target);
-      Reflect.defineMetadata(NESTJS_INJECTABLE_WATERMARK, true, target);
-    };
-  }
-  const [document, init] = args;
-  merge7(this, new CollectionClass(document, init), { descriptor: true });
-}, "Collection");
-Collection2.prototype = CollectionClass.prototype;
+
+// ../../build/common/esm/document/resource/collection-decorator.js
+import omit4 from "lodash.omit";
+import merge7 from "putil-merge";
+
+// ../../build/common/esm/document/resource/resource-decorator.js
+var ResourceDecorator = {};
+ResourceDecorator.Action = function(options) {
+  return (target, propertyKey) => {
+    if (typeof propertyKey !== "string")
+      throw new TypeError(`This decorator can't be used for Symbol keys'`);
+    const actionMeta = { ...options };
+    const resourceMetadata = Reflect.getOwnMetadata(RESOURCE_METADATA, target.constructor) || {};
+    resourceMetadata.actions = resourceMetadata.actions || {};
+    resourceMetadata.actions[propertyKey] = actionMeta;
+    Reflect.defineMetadata(RESOURCE_METADATA, resourceMetadata, target.constructor);
+  };
+};
+
+// ../../build/common/esm/document/resource/collection-decorator.js
+var NAME_PATTERN = /^(.*)(Resource|Collection|Controller)$/;
+var operationProperties = ["create", "delete", "deleteMany", "get", "findMany", "update", "updateMany"];
+function CollectionDecorator(type, options) {
+  return function(target) {
+    const name = options?.name || target.name.match(NAME_PATTERN)?.[1] || target.name;
+    const metadata = Reflect.getOwnMetadata(RESOURCE_METADATA, target) || {};
+    const baseMetadata = Reflect.getOwnMetadata(RESOURCE_METADATA, Object.getPrototypeOf(target));
+    if (baseMetadata) {
+      merge7(metadata, baseMetadata, { deep: true });
+    }
+    metadata.kind = opra_schema_ns_exports.Collection.Kind;
+    metadata.name = name;
+    metadata.type = type;
+    const m = Reflect.getMetadata(RESOURCE_METADATA, target);
+    if (m && metadata !== m)
+      Object.assign(metadata, omit4(m), Object.keys(metadata));
+    if (options)
+      Object.assign(metadata, omit4(options, ["kind", "name", "type", "controller"]));
+    Reflect.defineMetadata(RESOURCE_METADATA, metadata, target);
+  };
+}
+__name(CollectionDecorator, "CollectionDecorator");
+Object.assign(CollectionDecorator, ResourceDecorator);
+CollectionDecorator.Create = createOperationDecorator("create");
+CollectionDecorator.Delete = createOperationDecorator("delete");
+CollectionDecorator.DeleteMany = createOperationDecorator("deleteMany");
+CollectionDecorator.Get = createOperationDecorator("get");
+CollectionDecorator.FindMany = createOperationDecorator("findMany");
+CollectionDecorator.Update = createOperationDecorator("update");
+CollectionDecorator.UpdateMany = createOperationDecorator("updateMany");
+CollectionDecorator.Action = function(options) {
+  const oldDecorator = ResourceDecorator.Action(options);
+  return (target, propertyKey) => {
+    if (typeof propertyKey === "string" && operationProperties.includes(propertyKey))
+      throw new TypeError(`The "${propertyKey}" property is reserved for "${propertyKey}" operations and cannot be used as an action'`);
+    return oldDecorator(target, propertyKey);
+  };
+};
 function createOperationDecorator(operation) {
   return (options) => (target, propertyKey) => {
     if (propertyKey !== operation)
       throw new TypeError(`Name of the handler name should be '${operation}'`);
     const operationMeta = { ...options };
-    const resourceMetadata = Reflect.getOwnMetadata(METADATA_KEY, target.constructor) || {};
-    resourceMetadata.operations = resourceMetadata.operations || {};
-    resourceMetadata.operations[operation] = operationMeta;
-    Reflect.defineMetadata(METADATA_KEY, resourceMetadata, target.constructor);
+    const sourceMetadata = Reflect.getOwnMetadata(RESOURCE_METADATA, target.constructor) || {};
+    sourceMetadata.operations = sourceMetadata.operations || {};
+    sourceMetadata.operations[operation] = operationMeta;
+    Reflect.defineMetadata(RESOURCE_METADATA, sourceMetadata, target.constructor);
   };
 }
 __name(createOperationDecorator, "createOperationDecorator");
-Collection2.Create = createOperationDecorator("create");
-Collection2.Delete = createOperationDecorator("delete");
-Collection2.DeleteMany = createOperationDecorator("deleteMany");
-Collection2.Get = createOperationDecorator("get");
-Collection2.FindMany = createOperationDecorator("findMany");
-Collection2.Update = createOperationDecorator("update");
-Collection2.UpdateMany = createOperationDecorator("updateMany");
+
+// ../../build/common/esm/document/resource/collection.js
+var Collection2 = /* @__PURE__ */ __name(function(...args) {
+  if (!this) {
+    const [type, options] = args;
+    return Collection2[DECORATOR].call(void 0, type, options);
+  }
+  const [document, init] = args;
+  merge8(this, new CollectionClass(document, init), { descriptor: true });
+}, "Collection");
+Collection2.prototype = CollectionClass.prototype;
+Object.assign(Collection2, CollectionDecorator);
+Collection2[DECORATOR] = CollectionDecorator;
 
 // ../../build/common/esm/document/resource/singleton.js
-import omit5 from "lodash.omit";
-import merge8 from "putil-merge";
-var NESTJS_INJECTABLE_WATERMARK2 = "__injectable__";
-var NAME_PATTERN2 = /^(.*)(Resource|Singleton)$/;
+import merge9 from "putil-merge";
+
+// ../../build/common/esm/document/resource/singleton-class.js
 var SingletonClass = class extends Resource {
   static {
     __name(this, "SingletonClass");
@@ -10055,83 +10122,104 @@ var SingletonClass = class extends Resource {
     this.type = init.type;
   }
   exportSchema() {
-    const out = Resource.prototype.exportSchema.call(this);
-    Object.assign(out, omitUndefined({
-      type: this.type.name,
-      operations: this.operations
-    }));
-    return out;
+    return {
+      ...super.exportSchema(),
+      ...omitUndefined({
+        type: this.type.name || "any",
+        operations: this.operations
+      })
+    };
   }
   normalizeFieldPath(path2) {
     return this.type.normalizeFieldPath(path2);
   }
-  getDecoder(operation) {
-    let decoder = this._decoders[operation];
+  getDecoder(endpoint) {
+    let decoder = this._decoders[endpoint];
     if (decoder)
       return decoder;
     const options = {
-      partial: operation !== "create"
+      partial: endpoint !== "create"
     };
     decoder = generateCodec(this.type, "decode", options);
-    this._decoders[operation] = decoder;
+    this._decoders[endpoint] = decoder;
     return decoder;
   }
-  getEncoder(operation) {
-    let encoder = this._encoders[operation];
+  getEncoder(endpoint) {
+    let encoder = this._encoders[endpoint];
     if (encoder)
       return encoder;
     const options = {
       partial: true
     };
     encoder = generateCodec(this.type, "encode", options);
-    this._encoders[operation] = encoder;
+    this._encoders[endpoint] = encoder;
     return encoder;
   }
 };
-var Singleton2 = /* @__PURE__ */ __name(function(...args) {
-  if (!this) {
-    const [type, options] = args;
-    return function(target) {
-      const name = options?.name || target.name.match(NAME_PATTERN2)?.[1] || target.name;
-      const metadata = Reflect.getOwnMetadata(METADATA_KEY, target) || {};
-      metadata.kind = opra_schema_ns_exports.Singleton.Kind;
-      metadata.name = name;
-      metadata.type = type;
-      const m = Reflect.getMetadata(METADATA_KEY, target);
-      if (m && metadata !== m)
-        Object.assign(metadata, omit5(m), Object.keys(metadata));
-      if (options)
-        Object.assign(metadata, omit5(options, ["kind", "name", "type", "controller"]));
-      Reflect.defineMetadata(METADATA_KEY, metadata, target);
-      Reflect.defineMetadata(NESTJS_INJECTABLE_WATERMARK2, true, target);
-    };
-  }
-  const [document, init] = args;
-  merge8(this, new SingletonClass(document, init), { descriptor: true });
-}, "Singleton");
-Singleton2.prototype = SingletonClass.prototype;
+
+// ../../build/common/esm/document/resource/singleton-decorator.js
+import omit5 from "lodash.omit";
+var NAME_PATTERN2 = /^(.*)(Resource|Singleton|Controller)$/;
+function SingletonDecorator(type, options) {
+  return function(target) {
+    const name = options?.name || target.name.match(NAME_PATTERN2)?.[1] || target.name;
+    const metadata = Reflect.getOwnMetadata(RESOURCE_METADATA, target) || {};
+    metadata.kind = opra_schema_ns_exports.Singleton.Kind;
+    metadata.name = name;
+    metadata.type = type;
+    const m = Reflect.getMetadata(RESOURCE_METADATA, target);
+    if (m && metadata !== m)
+      Object.assign(metadata, omit5(m), Object.keys(metadata));
+    if (options)
+      Object.assign(metadata, omit5(options, ["kind", "name", "type", "controller"]));
+    Reflect.defineMetadata(RESOURCE_METADATA, metadata, target);
+  };
+}
+__name(SingletonDecorator, "SingletonDecorator");
+Object.assign(SingletonDecorator, ResourceDecorator);
+SingletonDecorator.Create = createOperationDecorator2("create");
+SingletonDecorator.Get = createOperationDecorator2("get");
+SingletonDecorator.Delete = createOperationDecorator2("delete");
+SingletonDecorator.Update = createOperationDecorator2("update");
+SingletonDecorator.Action = function(options) {
+  const oldDecorator = ResourceDecorator.Action(options);
+  const operators = ["create", "delete", "get", "update"];
+  return (target, propertyKey) => {
+    if (typeof propertyKey === "string" && operators.includes(propertyKey))
+      throw new TypeError(`The "${propertyKey}" property is reserved for "${propertyKey}" operations and cannot be used as an action'`);
+    return oldDecorator(target, propertyKey);
+  };
+};
 function createOperationDecorator2(operation) {
   return (options) => (target, propertyKey) => {
     if (propertyKey !== operation)
       throw new TypeError(`Name of the handler name should be '${operation}'`);
     const operationMeta = { ...options };
-    const resourceMetadata = Reflect.getOwnMetadata(METADATA_KEY, target.constructor) || {};
-    resourceMetadata.operations = resourceMetadata.operations || {};
-    resourceMetadata.operations[operation] = operationMeta;
-    Reflect.defineMetadata(METADATA_KEY, resourceMetadata, target.constructor);
+    const sourceMetadata = Reflect.getOwnMetadata(RESOURCE_METADATA, target.constructor) || {};
+    sourceMetadata.operations = sourceMetadata.operations || {};
+    sourceMetadata.operations[operation] = operationMeta;
+    Reflect.defineMetadata(RESOURCE_METADATA, sourceMetadata, target.constructor);
   };
 }
 __name(createOperationDecorator2, "createOperationDecorator");
-Singleton2.Create = createOperationDecorator2("create");
-Singleton2.Get = createOperationDecorator2("get");
-Singleton2.Delete = createOperationDecorator2("delete");
-Singleton2.Update = createOperationDecorator2("update");
+
+// ../../build/common/esm/document/resource/singleton.js
+var Singleton2 = /* @__PURE__ */ __name(function(...args) {
+  if (!this) {
+    const [type, options] = args;
+    return Singleton2[DECORATOR].call(void 0, type, options);
+  }
+  const [document, init] = args;
+  merge9(this, new SingletonClass(document, init), { descriptor: true });
+}, "Singleton");
+Singleton2.prototype = SingletonClass.prototype;
+Object.assign(Singleton2, SingletonDecorator);
+Singleton2[DECORATOR] = SingletonDecorator;
 
 // ../../build/common/esm/document/resource/storage.js
-import omit6 from "lodash.omit";
-import merge9 from "putil-merge";
-var NESTJS_INJECTABLE_WATERMARK3 = "__injectable__";
-var NAME_PATTERN3 = /^(.*)(Resource)$/;
+import merge10 from "putil-merge";
+
+// ../../build/common/esm/document/resource/storage-class.js
 var StorageClass = class extends Resource {
   static {
     __name(this, "StorageClass");
@@ -10143,71 +10231,94 @@ var StorageClass = class extends Resource {
     this.operations = { ...init.operations };
   }
   exportSchema() {
-    const out = Resource.prototype.exportSchema.call(this);
-    Object.assign(out, omitUndefined({
-      operations: this.operations
-    }));
-    return out;
-  }
-};
-var Storage2 = /* @__PURE__ */ __name(function(...args) {
-  if (!this) {
-    const [options] = args;
-    return function(target) {
-      const name = options?.name || target.name.match(NAME_PATTERN3)?.[1] || target.name;
-      const metadata = Reflect.getOwnMetadata(METADATA_KEY, target) || {};
-      metadata.kind = opra_schema_ns_exports.Storage.Kind;
-      metadata.name = name;
-      const m = Reflect.getMetadata(METADATA_KEY, target);
-      if (m && metadata !== m)
-        Object.assign(metadata, omit6(m), Object.keys(metadata));
-      if (options)
-        Object.assign(metadata, omit6(options, ["kind", "name", "type", "controller"]));
-      Reflect.defineMetadata(METADATA_KEY, metadata, target);
-      Reflect.defineMetadata(NESTJS_INJECTABLE_WATERMARK3, true, target);
+    return {
+      ...super.exportSchema(),
+      ...omitUndefined({
+        kind: opra_schema_ns_exports.Storage.Kind,
+        operations: this.operations
+      })
     };
   }
-  const [document, init] = args;
-  merge9(this, new StorageClass(document, init), { descriptor: true });
-}, "Storage");
-Storage2.prototype = StorageClass.prototype;
+};
+
+// ../../build/common/esm/document/resource/storage-decorator.js
+import omit6 from "lodash.omit";
+var NAME_PATTERN3 = /^(.*)(Resource|Storage|Controller)$/;
+function StorageDecorator(options) {
+  return function(target) {
+    const name = options?.name || target.name.match(NAME_PATTERN3)?.[1] || target.name;
+    const metadata = Reflect.getOwnMetadata(RESOURCE_METADATA, target) || {};
+    metadata.kind = opra_schema_ns_exports.Storage.Kind;
+    metadata.name = name;
+    const m = Reflect.getMetadata(RESOURCE_METADATA, target);
+    if (m && metadata !== m)
+      Object.assign(metadata, omit6(m), Object.keys(metadata));
+    if (options)
+      Object.assign(metadata, omit6(options, ["kind", "name", "type", "controller"]));
+    Reflect.defineMetadata(RESOURCE_METADATA, metadata, target);
+  };
+}
+__name(StorageDecorator, "StorageDecorator");
+Object.assign(StorageDecorator, ResourceDecorator);
+StorageDecorator.Delete = createOperationDecorator3("delete");
+StorageDecorator.Get = createOperationDecorator3("get");
+StorageDecorator.Post = createOperationDecorator3("post");
+StorageDecorator.Action = function(options) {
+  const oldDecorator = ResourceDecorator.Action(options);
+  const operators = ["delete", "get", "post"];
+  return (target, propertyKey) => {
+    if (typeof propertyKey === "string" && operators.includes(propertyKey))
+      throw new TypeError(`The "${propertyKey}" property is reserved for "${propertyKey}" operations and cannot be used as an action'`);
+    return oldDecorator(target, propertyKey);
+  };
+};
 function createOperationDecorator3(operation) {
   return (options) => (target, propertyKey) => {
     if (propertyKey !== operation)
       throw new TypeError(`Name of the handler name should be '${operation}'`);
     const operationMeta = { ...options };
-    const resourceMetadata = Reflect.getOwnMetadata(METADATA_KEY, target.constructor) || {};
-    resourceMetadata.operations = resourceMetadata.operations || {};
-    resourceMetadata.operations[operation] = operationMeta;
-    Reflect.defineMetadata(METADATA_KEY, resourceMetadata, target.constructor);
+    const sourceMetadata = Reflect.getOwnMetadata(RESOURCE_METADATA, target.constructor) || {};
+    sourceMetadata.operations = sourceMetadata.operations || {};
+    sourceMetadata.operations[operation] = operationMeta;
+    Reflect.defineMetadata(RESOURCE_METADATA, sourceMetadata, target.constructor);
   };
 }
 __name(createOperationDecorator3, "createOperationDecorator");
-Storage2.Delete = createOperationDecorator3("delete");
-Storage2.Get = createOperationDecorator3("get");
-Storage2.Post = createOperationDecorator3("post");
+
+// ../../build/common/esm/document/resource/storage.js
+var Storage2 = /* @__PURE__ */ __name(function(...args) {
+  if (!this) {
+    const [options] = args;
+    return Storage2[DECORATOR].call(void 0, options);
+  }
+  const [document, init] = args;
+  merge10(this, new StorageClass(document, init), { descriptor: true });
+}, "Storage");
+Storage2.prototype = StorageClass.prototype;
+Object.assign(Storage2, StorageDecorator);
+Storage2[DECORATOR] = StorageDecorator;
 
 // ../../build/common/esm/document/factory/process-resources.js
-async function processResourceQueue() {
-  const { document, resourceQueue } = this;
-  const resourceNames = Array.from(resourceQueue.keys());
-  for (const name of resourceNames) {
-    const schema = resourceQueue.get(name);
+async function processSourceQueue() {
+  const { document, sourceQueue } = this;
+  const sourceNames = Array.from(sourceQueue.keys());
+  for (const name of sourceNames) {
+    const schema = sourceQueue.get(name);
     if (!schema)
       continue;
     try {
       if (opra_schema_ns_exports.isCollection(schema)) {
-        const resource = await this.createCollectionResource(name, schema);
+        const resource = await this.createCollectionSource(name, schema);
         document.resources.set(name, resource);
         continue;
       }
       if (opra_schema_ns_exports.isSingleton(schema)) {
-        const resource = await this.createSingletonResource(name, schema);
+        const resource = await this.createSingletonSource(name, schema);
         document.resources.set(name, resource);
         continue;
       }
       if (opra_schema_ns_exports.isStorage(schema)) {
-        const resource = await this.createFileResource(name, schema);
+        const resource = await this.createFileSource(name, schema);
         document.resources.set(name, resource);
         continue;
       }
@@ -10218,7 +10329,7 @@ async function processResourceQueue() {
     throw new TypeError(`Invalid Resource schema: ${JSON.stringify(schema).substring(0, 20)}...`);
   }
 }
-__name(processResourceQueue, "processResourceQueue");
+__name(processSourceQueue, "processSourceQueue");
 async function createCollectionResource(name, schema) {
   const { document } = this;
   const dataType = document.getComplexType(schema.type);
@@ -10241,7 +10352,7 @@ async function createSingletonResource(name, schema) {
   return new Singleton2(document, initArgs);
 }
 __name(createSingletonResource, "createSingletonResource");
-async function createFileResource(name, schema) {
+async function createStorageResource(name, schema) {
   const { document } = this;
   const initArgs = {
     ...schema,
@@ -10249,7 +10360,7 @@ async function createFileResource(name, schema) {
   };
   return new Storage2(document, initArgs);
 }
-__name(createFileResource, "createFileResource");
+__name(createStorageResource, "createStorageResource");
 
 // ../../build/common/esm/document/factory/process-types.js
 async function processTypes() {
@@ -10429,7 +10540,7 @@ var DocumentFactory = class _DocumentFactory {
   constructor() {
     this.document = new ApiDocument();
     this.typeQueue = new ResponsiveMap();
-    this.resourceQueue = new ResponsiveMap();
+    this.sourceQueue = new ResponsiveMap();
     this.circularRefs = new ResponsiveMap();
     this.curPath = [];
     this.cache = /* @__PURE__ */ new Map();
@@ -10467,13 +10578,13 @@ DocumentFactory.designTypeMap = /* @__PURE__ */ new Map();
   _a2.prototype.processTypes = processTypes;
   _a2.prototype.createDataTypeInstance = createDataTypeInstance;
   _a2.prototype.addDataType = addDataType;
-  _a2.prototype.importResourceClass = importResourceClass;
+  _a2.prototype.importSourceClass = importResourceClass;
   _a2.prototype.extractSingletonSchema = extractSingletonSchema;
   _a2.prototype.extractCollectionSchema = extractCollectionSchema;
-  _a2.prototype.processResourceQueue = processResourceQueue;
-  _a2.prototype.createCollectionResource = createCollectionResource;
-  _a2.prototype.createSingletonResource = createSingletonResource;
-  _a2.prototype.createFileResource = createFileResource;
+  _a2.prototype.processSourceQueue = processSourceQueue;
+  _a2.prototype.createCollectionSource = createCollectionResource;
+  _a2.prototype.createSingletonSource = createSingletonResource;
+  _a2.prototype.createFileSource = createStorageResource;
 })();
 
 // ../../build/common/esm/http/opra-url.js
@@ -11188,6 +11299,8 @@ export {
   BaseI18n,
   Collection2 as Collection,
   ComplexType2 as ComplexType,
+  DATATYPE_METADATA,
+  DECORATOR,
   DataType,
   DocumentFactory,
   EnumType2 as EnumType,
@@ -11199,7 +11312,6 @@ export {
   I18n,
   InternalServerError,
   IssueSeverity,
-  METADATA_KEY,
   MappedType2 as MappedType,
   MethodNotAllowedError,
   NAMESPACE_PATTERN,
@@ -11212,6 +11324,7 @@ export {
   OpraURL,
   OpraURLPath,
   PickType,
+  RESOURCE_METADATA,
   Resource,
   ResourceConflictError,
   ResourceNotFoundError,