@opra/common 0.23.2 → 0.24.1

package/esm/document/resource/singleton.js

@@ -1,95 +1,17 @@
-import omit from 'lodash.omit';
 import merge from 'putil-merge';
-import { omitUndefined } from '../../helpers/index.js';
-import { OpraSchema } from '../../schema/index.js';
-import { METADATA_KEY } from '../constants.js';
-import { generateCodec } from '../utils/generate-codec.js';
-import { Resource } from './resource.js';
-const NESTJS_INJECTABLE_WATERMARK = '__injectable__'; // todo, put this in nextjs package wia augmentation
-const NAME_PATTERN = /^(.*)(Resource|Singleton)$/;
-class SingletonClass extends Resource {
-    constructor(document, init) {
-        super(document, init);
-        this._decoders = {};
-        this._encoders = {};
-        this.kind = OpraSchema.Singleton.Kind;
-        this.controller = init.controller;
-        this.operations = { ...init.operations };
-        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;
-    }
-    normalizeFieldPath(path) {
-        return this.type.normalizeFieldPath(path);
-    }
-    getDecoder(operation) {
-        let decoder = this._decoders[operation];
-        if (decoder)
-            return decoder;
-        const options = {
-            partial: operation !== 'create'
-        };
-        decoder = generateCodec(this.type, 'decode', options);
-        this._decoders[operation] = decoder;
-        return decoder;
-    }
-    getEncoder(operation) {
-        let encoder = this._encoders[operation];
-        if (encoder)
-            return encoder;
-        const options = {
-            partial: true
-        };
-        encoder = generateCodec(this.type, 'encode', options);
-        this._encoders[operation] = encoder;
-        return encoder;
-    }
-}
+import { DECORATOR } from '../constants.js';
+import { SingletonClass } from './singleton-class.js';
+import { SingletonDecorator } from './singleton-decorator.js';
 export const Singleton = function (...args) {
     // ClassDecorator
     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) || {};
-            metadata.kind = OpraSchema.Singleton.Kind;
-            metadata.name = name;
-            metadata.type = type;
-            // Merge with previous metadata object
-            const m = Reflect.getMetadata(METADATA_KEY, target);
-            if (m && metadata !== m)
-                Object.assign(metadata, omit(m), Object.keys(metadata));
-            // Merge options
-            if (options)
-                Object.assign(metadata, omit(options, ['kind', 'name', 'type', 'controller']));
-            Reflect.defineMetadata(METADATA_KEY, metadata, target);
-            /* Define Injectable metadata for NestJS support*/
-            Reflect.defineMetadata(NESTJS_INJECTABLE_WATERMARK, true, target);
-        };
+        return Singleton[DECORATOR].call(undefined, type, options);
     }
     // Constructor
     const [document, init] = args;
     merge(this, new SingletonClass(document, init), { descriptor: true });
 };
 Singleton.prototype = SingletonClass.prototype;
-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);
-    });
-}
-Singleton.Create = createOperationDecorator('create');
-Singleton.Get = createOperationDecorator('get');
-Singleton.Delete = createOperationDecorator('delete');
-Singleton.Update = createOperationDecorator('update');
+Object.assign(Singleton, SingletonDecorator);
+Singleton[DECORATOR] = SingletonDecorator;

package/esm/document/resource/storage-class.js

@@ -0,0 +1,20 @@
+import { omitUndefined } from '../../helpers/index.js';
+import { OpraSchema } from '../../schema/index.js';
+import { Resource } from './resource.js';
+export class StorageClass extends Resource {
+    constructor(document, init) {
+        super(document, init);
+        this.kind = OpraSchema.Storage.Kind;
+        this.controller = init.controller;
+        this.operations = { ...init.operations };
+    }
+    exportSchema() {
+        return {
+            ...super.exportSchema(),
+            ...omitUndefined({
+                kind: OpraSchema.Storage.Kind,
+                operations: this.operations
+            })
+        };
+    }
+}

package/esm/document/resource/storage-decorator.js

@@ -0,0 +1,46 @@
+import omit from 'lodash.omit';
+import { OpraSchema } from '../../schema/index.js';
+import { RESOURCE_METADATA } from '../constants.js';
+import { ResourceDecorator } from './resource-decorator.js';
+const NAME_PATTERN = /^(.*)(Resource|Storage|Controller)$/;
+const operationProperties = ['delete', 'get', 'post'];
+export function StorageDecorator(options) {
+    return function (target) {
+        const name = options?.name || target.name.match(NAME_PATTERN)?.[1] || target.name;
+        const metadata = Reflect.getOwnMetadata(RESOURCE_METADATA, target) || {};
+        metadata.kind = OpraSchema.Storage.Kind;
+        metadata.name = name;
+        // Merge with previous metadata object
+        const m = Reflect.getMetadata(RESOURCE_METADATA, target);
+        if (m && metadata !== m)
+            Object.assign(metadata, omit(m), Object.keys(metadata));
+        // Merge options
+        if (options)
+            Object.assign(metadata, omit(options, ['kind', 'name', 'type', 'controller']));
+        Reflect.defineMetadata(RESOURCE_METADATA, metadata, target);
+    };
+}
+Object.assign(StorageDecorator, ResourceDecorator);
+StorageDecorator.Delete = createOperationDecorator('delete');
+StorageDecorator.Get = createOperationDecorator('get');
+StorageDecorator.Post = createOperationDecorator('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 createOperationDecorator(operation) {
+    return (options) => ((target, propertyKey) => {
+        if (propertyKey !== operation)
+            throw new TypeError(`Name of the handler name should be '${operation}'`);
+        const operationMeta = { ...options };
+        const sourceMetadata = (Reflect.getOwnMetadata(RESOURCE_METADATA, target.constructor) || {});
+        sourceMetadata.operations = sourceMetadata.operations || {};
+        sourceMetadata.operations[operation] = operationMeta;
+        Reflect.defineMetadata(RESOURCE_METADATA, sourceMetadata, target.constructor);
+    });
+}

package/esm/document/resource/storage.js

@@ -1,63 +1,17 @@
-import omit from 'lodash.omit';
 import merge from 'putil-merge';
-import { omitUndefined } from '../../helpers/index.js';
-import { OpraSchema } from '../../schema/index.js';
-import { METADATA_KEY } from '../constants.js';
-import { Resource } from './resource.js';
-const NESTJS_INJECTABLE_WATERMARK = '__injectable__';
-const NAME_PATTERN = /^(.*)(Resource)$/;
-class StorageClass extends Resource {
-    constructor(document, init) {
-        super(document, init);
-        this.kind = OpraSchema.Storage.Kind;
-        this.controller = init.controller;
-        this.operations = { ...init.operations };
-    }
-    exportSchema() {
-        const out = Resource.prototype.exportSchema.call(this);
-        Object.assign(out, omitUndefined({
-            operations: this.operations
-        }));
-        return out;
-    }
-}
+import { DECORATOR } from '../constants.js';
+import { StorageClass } from './storage-class.js';
+import { StorageDecorator } from './storage-decorator.js';
 export const Storage = function (...args) {
     // ClassDecorator
     if (!this) {
         const [options] = args;
-        return function (target) {
-            const name = options?.name || target.name.match(NAME_PATTERN)?.[1] || target.name;
-            const metadata = Reflect.getOwnMetadata(METADATA_KEY, target) || {};
-            metadata.kind = OpraSchema.Storage.Kind;
-            metadata.name = name;
-            // Merge with previous metadata object
-            const m = Reflect.getMetadata(METADATA_KEY, target);
-            if (m && metadata !== m)
-                Object.assign(metadata, omit(m), Object.keys(metadata));
-            // Merge options
-            if (options)
-                Object.assign(metadata, omit(options, ['kind', 'name', 'type', 'controller']));
-            Reflect.defineMetadata(METADATA_KEY, metadata, target);
-            /* Define Injectable metadata for NestJS support*/
-            Reflect.defineMetadata(NESTJS_INJECTABLE_WATERMARK, true, target);
-        };
+        return Storage[DECORATOR].call(undefined, options);
     }
     // Constructor
     const [document, init] = args;
     merge(this, new StorageClass(document, init), { descriptor: true });
 };
 Storage.prototype = StorageClass.prototype;
-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);
-    });
-}
-Storage.Delete = createOperationDecorator('delete');
-Storage.Get = createOperationDecorator('get');
-Storage.Post = createOperationDecorator('post');
+Object.assign(Storage, StorageDecorator);
+Storage[DECORATOR] = StorageDecorator;

package/esm/document/utils/generate-codec.js

@@ -5,9 +5,9 @@ import { MappedType } from '../data-type/mapped-type.js';
 import { SimpleType } from '../data-type/simple-type.js';
 import { UnionType } from '../data-type/union-type.js';
 export function generateCodec(type, codec, options) {
-    return _generateDecoder(type, codec, options);
+    return _generateCodec(type, codec, options);
 }
-export function _generateDecoder(type, codec, options) {
+export function _generateCodec(type, codec, options) {
     const schema = {};
     for (const f of type.fields.values()) {
         let fn;
@@ -15,7 +15,7 @@ export function _generateDecoder(type, codec, options) {
             fn = f.type[codec];
         }
         else if (f.type instanceof ComplexType || f.type instanceof MappedType || f.type instanceof UnionType) {
-            fn = _generateDecoder(f.type, codec, options);
+            fn = _generateCodec(f.type, codec, options);
         }
         /* istanbul ignore next */
         if (!fn)

package/esm/exception/resource-errors/resource-not-found.error.js

@@ -7,7 +7,7 @@ import { OpraException } from '../opra-exception.js';
 export class ResourceNotFoundError 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: {

package/esm/helpers/mixin-utils.js

@@ -8,11 +8,11 @@ export function mergePrototype(targetProto, baseProto, filter) {
     }
 }
 // noinspection JSUnusedLocalSymbols
-export function inheritPropertyInitializers(target, sourceClass, 
+export function inheritPropertyInitializers(target, clazz, 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 isPropertyInherited = (key) => true) {
     try {
-        const tempInstance = new sourceClass();
+        const tempInstance = new clazz();
         const propertyNames = Object.getOwnPropertyNames(tempInstance);
         propertyNames
             .filter((propertyName) => typeof tempInstance[propertyName] !== 'undefined' &&

package/esm/schema/opra-schema.ns.js

@@ -7,7 +7,6 @@ export * from './data-type/mapped-type.interface.js';
 export * from './data-type/union-type.interface.js';
 export * from './resource/collection.interface.js';
 export * from './resource/container.interface.js';
-export * from './resource/operation.interface.js';
 export * from './resource/resource.interface.js';
 export * from './resource/singleton.interface.js';
 export * from './resource/storage.interface.js';

package/esm/schema/type-guards.js

@@ -30,11 +30,12 @@ export function isMappedType(obj) {
 export function isEnumType(obj) {
     return obj && typeof obj === 'object' && obj.kind === EnumType.Kind;
 }
-export function isResource(obj) {
+export function isSource(obj) {
     return obj && typeof obj === 'object' &&
         (obj.kind === Container.Kind ||
             obj.kind === Collection.Kind ||
-            obj.kind === Singleton.Kind);
+            obj.kind === Singleton.Kind ||
+            obj.kind === Storage.Kind);
 }
 export function isCollection(obj) {
     return obj && typeof obj === 'object' && obj.kind === Collection.Kind;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/common",
-  "version": "0.23.2",
+  "version": "0.24.1",
   "description": "Opra common package",
   "author": "Panates",
   "license": "MIT",

package/types/document/api-document.d.ts

@@ -4,7 +4,7 @@ import { OpraSchema } from '../schema/index.js';
 import { ComplexType } from './data-type/complex-type.js';
 import type { DataType } from './data-type/data-type.js';
 import { SimpleType } from './data-type/simple-type.js';
-import type { Collection } from './resource/collection.js';
+import { Collection } from './resource/collection.js';
 import { Resource } from './resource/resource.js';
 import { Singleton } from './resource/singleton.js';
 import { Storage } from './resource/storage.js';

package/types/document/constants.d.ts

@@ -1,3 +1,5 @@
-export declare const METADATA_KEY: unique symbol;
+export declare const DATATYPE_METADATA: unique symbol;
+export declare const RESOURCE_METADATA: unique symbol;
+export declare const DECORATOR: unique symbol;
 export declare const NAMESPACE_PATTERN: RegExp;
 export declare const TYPENAME_PATTERN: RegExp;

package/types/document/data-type/mapped-type.d.ts

@@ -49,11 +49,11 @@ export interface MappedType extends MappedTypeClass {
 export interface MappedTypeConstructor {
     prototype: MappedType;
     new (document: ApiDocument, init: MappedType.InitArguments): MappedType;
-    <T extends any[], I1, S1, PickKey extends keyof I1, OmitKey extends keyof I1>(source: Class<T, I1, S1>, options: {
+    <T extends any[], I1, S1, PickKey extends keyof I1, OmitKey extends keyof I1>(resource: Class<T, I1, S1>, options: {
         pickKeys?: readonly PickKey[];
         omitKeys?: readonly OmitKey[];
     }): Class<T, Omit<Pick<I1, PickKey>, OmitKey>>;
-    _applyMixin(target: Type, source: Type, options: MappedType.Options<any> & {
+    _applyMixin(targetType: Type, sourceType: Type, options: MappedType.Options<any> & {
         isInheritedPredicate: (fieldName: string) => boolean;
     }): void;
 }

package/types/document/factory/factory.d.ts

@@ -7,7 +7,7 @@ import { addReferences } from './add-references.js';
 import { createBuiltinTypeDocument, createDocument, createDocumentFromUrl } from './create-document.js';
 import { extractCollectionSchema, extractSingletonSchema, importResourceClass } from './import-resource-class.js';
 import { extractComplexTypeSchema, extractEnumTypeSchema, extractFieldSchema, extractMappedTypeSchema, extractSimpleTypeSchema, extractUnionTypeSchema, importTypeClass } from './import-type-class.js';
-import { createCollectionResource, createFileResource, createSingletonResource, processResourceQueue } from './process-resources.js';
+import { createCollectionResource, createSingletonResource, createStorageResource, processSourceQueue } from './process-resources.js';
 import { addDataType, createDataTypeInstance, processTypes } from './process-types.js';
 /**
  * @namespace DocumentFactory
@@ -26,7 +26,7 @@ export declare class DocumentFactory {
     static designTypeMap: Map<Function | Type<any>, string>;
     protected document: ApiDocument;
     protected typeQueue: ResponsiveMap<OpraSchema.DataType>;
-    protected resourceQueue: ResponsiveMap<OpraSchema.Resource>;
+    protected sourceQueue: ResponsiveMap<OpraSchema.Resource>;
     protected circularRefs: ResponsiveMap<any>;
     protected curPath: string[];
     protected cache: Map<any, any>;
@@ -44,13 +44,13 @@ export declare class DocumentFactory {
     protected processTypes: typeof processTypes;
     protected createDataTypeInstance: typeof createDataTypeInstance;
     protected addDataType: typeof addDataType;
-    protected importResourceClass: typeof importResourceClass;
+    protected importSourceClass: typeof importResourceClass;
     protected extractSingletonSchema: typeof extractSingletonSchema;
     protected extractCollectionSchema: typeof extractCollectionSchema;
-    protected processResourceQueue: typeof processResourceQueue;
-    protected createCollectionResource: typeof createCollectionResource;
-    protected createSingletonResource: typeof createSingletonResource;
-    protected createFileResource: typeof createFileResource;
+    protected processSourceQueue: typeof processSourceQueue;
+    protected createCollectionSource: typeof createCollectionResource;
+    protected createSingletonSource: typeof createSingletonResource;
+    protected createFileSource: typeof createStorageResource;
     /**
      * Creates ApiDocument instance from given schema object
      * @param init

package/types/document/factory/process-resources.d.ts

@@ -3,7 +3,7 @@ import { Collection } from '../resource/collection.js';
 import { Singleton } from '../resource/singleton.js';
 import { Storage } from '../resource/storage.js';
 import type { DocumentFactory } from './factory.js';
-export declare function processResourceQueue(this: DocumentFactory): Promise<void>;
+export declare function processSourceQueue(this: DocumentFactory): Promise<void>;
 export declare function createCollectionResource(this: DocumentFactory, name: string, schema: OpraSchema.Collection): Promise<Collection>;
 export declare function createSingletonResource(this: DocumentFactory, name: string, schema: OpraSchema.Singleton): Promise<Singleton>;
-export declare function createFileResource(this: DocumentFactory, name: string, schema: OpraSchema.Storage): Promise<Storage>;
+export declare function createStorageResource(this: DocumentFactory, name: string, schema: OpraSchema.Storage): Promise<Storage>;

package/types/document/index.d.ts

@@ -13,5 +13,6 @@ export * from './resource/resource.js';
 export * from './resource/collection.js';
 export * from './resource/singleton.js';
 export * from './resource/storage.js';
-export * from './interfaces/collection-resource.interface.js';
-export * from './interfaces/singleton-resource.interface.js';
+export * from './interfaces/collection.interface.js';
+export * from './interfaces/singleton.interface.js';
+export * from './interfaces/storage.interface.js';

package/types/document/interfaces/{collection-resource.interface.d.ts → collection.interface.d.ts}

@@ -1,5 +1,5 @@
 import { PartialOutput } from '../../types.js';
-export interface CollectionResource<T> {
+export interface ICollection<T> {
     create?(...args: any[]): Promise<PartialOutput<T>>;
     delete?(...args: any[]): Promise<number> | undefined;
     deleteMany?(...args: any[]): Promise<number> | undefined;

package/types/document/interfaces/{singleton-resource.interface.d.ts → singleton.interface.d.ts}

@@ -1,5 +1,5 @@
 import { PartialOutput } from '../../types.js';
-export interface SingletonResource<T> {
+export interface ISingleton<T> {
     create?(...args: any[]): Promise<PartialOutput<T>>;
     delete?(...args: any[]): Promise<number> | undefined;
     get?(...args: any[]): Promise<PartialOutput<T> | undefined>;

package/types/document/interfaces/{storage-resource.interface.d.ts → storage.interface.d.ts}

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import { Readable } from 'stream';
-export interface StorageResource {
+export interface IStorage {
     delete?(...args: any[]): Promise<number | undefined>;
     get?(...args: any[]): Promise<Buffer | Readable | undefined>;
     post?(...args: any[]): Promise<void>;

package/types/document/resource/action.d.ts

@@ -0,0 +1,11 @@
+import { OpraSchema } from '../../schema/index.js';
+export declare namespace Action {
+    interface InitArguments extends OpraSchema.Action {
+        name: string;
+    }
+}
+export declare class Action {
+    readonly name: string;
+    constructor(init: Action.InitArguments);
+    exportSchema(): OpraSchema.Action;
+}

package/types/document/resource/collection-class.d.ts

@@ -0,0 +1,24 @@
+import * as vg from 'valgen';
+import { OpraFilter } from '../../filter/index.js';
+import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document.js';
+import { ComplexType } from '../data-type/complex-type.js';
+import type { Collection } from './collection.js';
+import { Resource } from './resource.js';
+export declare class CollectionClass extends Resource {
+    private _decoders;
+    private _encoders;
+    readonly type: ComplexType;
+    readonly kind = "Collection";
+    readonly operations: OpraSchema.Collection.Operations;
+    readonly controller?: object;
+    readonly primaryKey: string[];
+    constructor(document: ApiDocument, init: Collection.InitArguments);
+    exportSchema(): OpraSchema.Collection;
+    parseKeyValue(value: any): any;
+    normalizeFieldPath(path: string | string[]): string[] | undefined;
+    normalizeSortFields(this: Collection, fields: string | string[]): string[] | undefined;
+    normalizeFilter(filter: string | OpraFilter.Expression): OpraFilter.Expression | undefined;
+    getDecoder(endpoint: keyof OpraSchema.Collection.Operations): vg.Validator<any, any>;
+    getEncoder(endpoint: keyof OpraSchema.Collection.Operations): vg.Validator<any, any>;
+}

package/types/document/resource/collection-decorator.d.ts

@@ -0,0 +1,30 @@
+import { StrictOmit, Type } from 'ts-gems';
+import type { Collection } from './collection.js';
+import { Resource } from './resource.js';
+import { ResourceDecorator } from './resource-decorator.js';
+type ErrorMessage<T, Error> = [T] extends [never] ? Error : T;
+declare const operationProperties: readonly ["create", "delete", "deleteMany", "get", "findMany", "update", "updateMany"];
+type OperationProperties = typeof operationProperties[number];
+export interface CollectionDecorator extends StrictOmit<ResourceDecorator, 'Action'> {
+    <T>(type: Type<T> | string, options?: Collection.DecoratorOptions<T>): ClassDecorator;
+    Action: (options?: Resource.ActionOptions) => (<T, K extends keyof T>(target: T, propertyKey: ErrorMessage<Exclude<K, OperationProperties>, `'${string & K}' property is reserved for operation endpoints and can not be used for actions`>) => void);
+    Create: (options?: Collection.CreateEndpointOptions) => ((target: Object, propertyKey: 'create') => void);
+    Delete: (options?: Collection.DeleteEndpointOptions) => ((target: Object, propertyKey: 'delete') => void);
+    DeleteMany: (options?: Collection.DeleteManyEndpointOptions) => ((target: Object, propertyKey: 'deleteMany') => void);
+    Get: (options?: Collection.GetEndpointOptions) => ((target: Object, propertyKey: 'get') => void);
+    FindMany: (options?: Collection.FindManyEndpointOptions) => ((target: Object, propertyKey: 'findMany') => void);
+    Update: (options?: Collection.UpdateEndpointOptions) => ((target: Object, propertyKey: 'update') => void);
+    UpdateMany: (options?: Collection.UpdateManyEndpointOptions) => ((target: Object, propertyKey: 'updateMany') => void);
+}
+export declare function CollectionDecorator(type: Type | string, options?: Collection.DecoratorOptions): ClassDecorator;
+export declare namespace CollectionDecorator {
+    var Create: (options?: unknown) => (target: Object, propertyKey: string | symbol) => void;
+    var Delete: (options?: unknown) => (target: Object, propertyKey: string | symbol) => void;
+    var DeleteMany: (options?: unknown) => (target: Object, propertyKey: string | symbol) => void;
+    var Get: (options?: unknown) => (target: Object, propertyKey: string | symbol) => void;
+    var FindMany: (options?: unknown) => (target: Object, propertyKey: string | symbol) => void;
+    var Update: (options?: unknown) => (target: Object, propertyKey: string | symbol) => void;
+    var UpdateMany: (options?: unknown) => (target: Object, propertyKey: string | symbol) => void;
+    var Action: (options: any) => PropertyDecorator;
+}
+export {};

package/types/document/resource/collection.d.ts

@@ -1,10 +1,10 @@
-import { StrictOmit, Type } from 'ts-gems';
-import * as vg from 'valgen';
-import { OpraFilter } from '../../filter/index.js';
+import { StrictOmit } from 'ts-gems';
 import { OpraSchema } from '../../schema/index.js';
 import type { TypeThunkAsync } from '../../types.js';
 import type { ApiDocument } from '../api-document.js';
 import { ComplexType } from '../data-type/complex-type.js';
+import { CollectionClass } from './collection-class.js';
+import { CollectionDecorator } from './collection-decorator.js';
 import { Resource } from './resource.js';
 export declare namespace Collection {
     interface InitArguments extends Resource.InitArguments, StrictOmit<OpraSchema.Collection, 'kind' | 'type'> {
@@ -13,8 +13,7 @@ export declare namespace Collection {
     interface DecoratorOptions<T = any> extends Resource.DecoratorOptions {
         primaryKey?: keyof T | (keyof T)[];
     }
-    interface Metadata extends StrictOmit<OpraSchema.Collection, 'type'> {
-        name: string;
+    interface Metadata extends StrictOmit<Resource.Metadata, 'kind'>, StrictOmit<OpraSchema.Collection, 'type'> {
         type: TypeThunkAsync | string;
     }
     namespace Create {
@@ -31,42 +30,17 @@ export declare namespace Collection {
     }
     namespace UpdateMany {
     }
-    type CreateOperationOptions = OpraSchema.Collection.CreateOperation;
-    type DeleteOperationOptions = OpraSchema.Collection.DeleteOperation;
-    type DeleteManyOperationOptions = OpraSchema.Collection.DeleteManyOperation;
-    type FindManyOperationOptions = OpraSchema.Collection.FindManyOperation;
-    type GetOperationOptions = OpraSchema.Collection.GetOperation;
-    type UpdateOperationOptions = OpraSchema.Collection.UpdateOperation;
-    type UpdateManyOperationOptions = OpraSchema.Collection.UpdateManyOperation;
+    type CreateEndpointOptions = OpraSchema.Collection.CreateEndpoint;
+    type DeleteEndpointOptions = OpraSchema.Collection.DeleteEndpoint;
+    type DeleteManyEndpointOptions = OpraSchema.Collection.DeleteManyEndpoint;
+    type FindManyEndpointOptions = OpraSchema.Collection.FindManyEndpoint;
+    type GetEndpointOptions = OpraSchema.Collection.GetEndpoint;
+    type UpdateEndpointOptions = OpraSchema.Collection.UpdateEndpoint;
+    type UpdateManyEndpointOptions = OpraSchema.Collection.UpdateManyEndpoint;
 }
-declare class CollectionClass extends Resource {
-    private _decoders;
-    private _encoders;
-    readonly type: ComplexType;
-    readonly kind = "Collection";
-    readonly operations: OpraSchema.Collection.Operations;
-    readonly controller?: object;
-    readonly primaryKey: string[];
-    constructor(document: ApiDocument, init: Collection.InitArguments);
-    exportSchema(this: Collection): OpraSchema.Collection;
-    parseKeyValue(this: Collection, value: any): any;
-    normalizeFieldPath(this: Collection, path: string | string[]): string[] | undefined;
-    normalizeSortFields(this: Collection, fields: string | string[]): string[] | undefined;
-    normalizeFilter(filter: string | OpraFilter.Expression): OpraFilter.Expression | undefined;
-    getDecoder(operation: keyof OpraSchema.Collection.Operations): vg.Validator<any, any>;
-    getEncoder(operation: keyof OpraSchema.Collection.Operations): vg.Validator<any, any>;
-}
-export interface CollectionConstructor {
+export interface CollectionConstructor extends CollectionDecorator {
     prototype: Collection;
     new (document: ApiDocument, init: Collection.InitArguments): Collection;
-    <T>(type: Type<T> | string, options?: Collection.DecoratorOptions<T>): ClassDecorator;
-    Create: (options?: Collection.CreateOperationOptions) => ((target: Object, propertyKey: 'create') => void);
-    Delete: (options?: Collection.DeleteOperationOptions) => ((target: Object, propertyKey: 'delete') => void);
-    DeleteMany: (options?: Collection.DeleteManyOperationOptions) => ((target: Object, propertyKey: 'deleteMany') => void);
-    Get: (options?: Collection.GetOperationOptions) => ((target: Object, propertyKey: 'get') => void);
-    FindMany: (options?: Collection.FindManyOperationOptions) => ((target: Object, propertyKey: 'findMany') => void);
-    Update: (options?: Collection.UpdateOperationOptions) => ((target: Object, propertyKey: 'update') => void);
-    UpdateMany: (options?: Collection.UpdateManyOperationOptions) => ((target: Object, propertyKey: 'updateMany') => void);
 }
 export interface Collection extends CollectionClass {
 }
@@ -74,4 +48,3 @@ export interface Collection extends CollectionClass {
  *
  */
 export declare const Collection: CollectionConstructor;
-export {};

package/types/document/resource/resource-decorator.d.ts

@@ -0,0 +1,5 @@
+import type { Resource } from './resource.js';
+export interface ResourceDecorator {
+    Action: (options?: Resource.ActionOptions) => PropertyDecorator;
+}
+export declare const ResourceDecorator: ResourceDecorator;

package/types/document/resource/resource.d.ts

@@ -2,6 +2,7 @@ import { StrictOmit, Type } from 'ts-gems';
 import { OpraSchema } from '../../schema/index.js';
 import type { ApiDocument } from '../api-document.js';
 import { nodeInspectCustom } from '../utils/inspect.util.js';
+import { Action } from './action.js';
 export declare namespace Resource {
     interface InitArguments extends StrictOmit<OpraSchema.ResourceBase, 'kind'> {
         name: string;
@@ -9,6 +10,11 @@ export declare namespace Resource {
     }
     interface DecoratorOptions extends Partial<Pick<InitArguments, 'name' | 'description'>> {
     }
+    interface Metadata extends OpraSchema.ResourceBase {
+        name: string;
+    }
+    interface ActionOptions {
+    }
 }
 export declare abstract class Resource {
     readonly document: ApiDocument;
@@ -17,6 +23,7 @@ export declare abstract class Resource {
     readonly description?: string;
     readonly controller?: object | Type;
     abstract readonly operations: Record<string, any>;
+    readonly actions: Record<string, Action>;
     protected constructor(document: ApiDocument, init: Resource.InitArguments);
     exportSchema(): OpraSchema.ResourceBase;
     toString(): string;