@opra/common 0.23.2 → 0.24.1

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

@@ -0,0 +1,20 @@
+import { Type } from 'ts-gems';
+import * as vg from 'valgen';
+import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document.js';
+import { ComplexType } from '../data-type/complex-type.js';
+import { Resource } from './resource.js';
+import type { Singleton } from './singleton.js';
+export declare class SingletonClass extends Resource {
+    private _decoders;
+    private _encoders;
+    readonly type: ComplexType;
+    readonly kind = "Singleton";
+    readonly operations: OpraSchema.Singleton.Operations;
+    readonly controller?: object | Type;
+    constructor(document: ApiDocument, init: Singleton.InitArguments);
+    exportSchema(): OpraSchema.Singleton;
+    normalizeFieldPath(path: string | string[]): string[] | undefined;
+    getDecoder(endpoint: keyof OpraSchema.Singleton.Operations): vg.Validator<any, any>;
+    getEncoder(endpoint: keyof OpraSchema.Singleton.Operations): vg.Validator<any, any>;
+}

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

@@ -0,0 +1,25 @@
+import { StrictOmit } from 'ts-gems';
+import { TypeThunkAsync } from '../../types.js';
+import { Resource } from './resource.js';
+import { ResourceDecorator } from './resource-decorator.js';
+import type { Singleton } from './singleton.js';
+type ErrorMessage<T, Error> = [T] extends [never] ? Error : T;
+declare const operationProperties: readonly ["create", "delete", "get", "update"];
+type OperationProperties = typeof operationProperties[number];
+export interface SingletonDecorator extends StrictOmit<ResourceDecorator, 'Action'> {
+    (type: TypeThunkAsync | string, options?: Singleton.DecoratorOptions): 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?: Singleton.CreateEndpointOptions) => ((target: Object, propertyKey: 'create') => void);
+    Delete: (options?: Singleton.DeleteEndpointOptions) => ((target: Object, propertyKey: 'delete') => void);
+    Get: (options?: Singleton.GetEndpointOptions) => ((target: Object, propertyKey: 'get') => void);
+    Update: (options?: Singleton.UpdateEndpointOptions) => ((target: Object, propertyKey: 'update') => void);
+}
+export declare function SingletonDecorator(type: TypeThunkAsync | string, options?: Singleton.DecoratorOptions): ClassDecorator;
+export declare namespace SingletonDecorator {
+    var Create: (options?: unknown) => (target: Object, propertyKey: string | symbol) => void;
+    var Get: (options?: unknown) => (target: Object, propertyKey: string | symbol) => void;
+    var Delete: (options?: unknown) => (target: Object, propertyKey: string | symbol) => void;
+    var Update: (options?: unknown) => (target: Object, propertyKey: string | symbol) => void;
+    var Action: (options: any) => PropertyDecorator;
+}
+export {};

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

@@ -1,18 +1,18 @@
-import { StrictOmit, Type } from 'ts-gems';
-import * as vg from 'valgen';
+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 { Resource } from './resource.js';
+import type { Resource } from './resource.js';
+import { SingletonClass } from './singleton-class.js';
+import { SingletonDecorator } from './singleton-decorator.js';
 export declare namespace Singleton {
     interface InitArguments extends Resource.InitArguments, StrictOmit<OpraSchema.Singleton, 'kind' | 'type'> {
         type: ComplexType;
     }
     interface DecoratorOptions extends Resource.DecoratorOptions {
     }
-    interface Metadata extends StrictOmit<OpraSchema.Singleton, 'type'> {
-        name: string;
+    interface Metadata extends StrictOmit<Resource.Metadata, 'kind'>, StrictOmit<OpraSchema.Singleton, 'type'> {
         type: TypeThunkAsync | string;
     }
     namespace Create {
@@ -23,34 +23,15 @@ export declare namespace Singleton {
     }
     namespace Update {
     }
-    type CreateOperationOptions = OpraSchema.Singleton.CreateOperation;
-    type DeleteOperationOptions = OpraSchema.Singleton.DeleteOperation;
-    type GetOperationOptions = OpraSchema.Singleton.GetOperation;
-    type UpdateOperationOptions = OpraSchema.Singleton.UpdateOperation;
+    type CreateEndpointOptions = OpraSchema.Singleton.CreateEndpoint;
+    type DeleteEndpointOptions = OpraSchema.Singleton.DeleteEndpoint;
+    type GetEndpointOptions = OpraSchema.Singleton.GetEndpoint;
+    type UpdateEndpointOptions = OpraSchema.Singleton.UpdateEndpoint;
 }
-declare class SingletonClass extends Resource {
-    private _decoders;
-    private _encoders;
-    readonly type: ComplexType;
-    readonly kind = "Singleton";
-    readonly operations: OpraSchema.Singleton.Operations;
-    readonly controller?: object | Type;
-    constructor(document: ApiDocument, init: Singleton.InitArguments);
-    exportSchema(): OpraSchema.Singleton;
-    normalizeFieldPath(this: Singleton, path: string | string[]): string[] | undefined;
-    getDecoder(operation: keyof OpraSchema.Singleton.Operations): vg.Validator<any, any>;
-    getEncoder(operation: keyof OpraSchema.Singleton.Operations): vg.Validator<any, any>;
-}
-export interface SingletonConstructor {
+export interface SingletonConstructor extends SingletonDecorator {
     prototype: Singleton;
     new (document: ApiDocument, init: Singleton.InitArguments): Singleton;
-    (type: TypeThunkAsync | string, options?: Singleton.DecoratorOptions): ClassDecorator;
-    Create: (options?: Singleton.CreateOperationOptions) => ((target: Object, propertyKey: 'create') => void);
-    Delete: (options?: Singleton.DeleteOperationOptions) => ((target: Object, propertyKey: 'delete') => void);
-    Get: (options?: Singleton.GetOperationOptions) => ((target: Object, propertyKey: 'get') => void);
-    Update: (options?: Singleton.UpdateOperationOptions) => ((target: Object, propertyKey: 'update') => void);
 }
 export interface Singleton extends SingletonClass {
 }
 export declare const Singleton: SingletonConstructor;
-export {};

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

@@ -0,0 +1,12 @@
+import { Type } from 'ts-gems';
+import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document.js';
+import { Resource } from './resource.js';
+import type { Storage } from './storage.js';
+export declare class StorageClass extends Resource {
+    readonly kind = "Storage";
+    readonly operations: OpraSchema.Storage.Operations;
+    readonly controller?: object | Type;
+    constructor(document: ApiDocument, init: Storage.InitArguments);
+    exportSchema(): OpraSchema.Storage;
+}

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

@@ -0,0 +1,22 @@
+import { StrictOmit } from 'ts-gems';
+import { Resource } from './resource.js';
+import { ResourceDecorator } from './resource-decorator.js';
+import type { Storage } from './storage.js';
+type ErrorMessage<T, Error> = [T] extends [never] ? Error : T;
+declare const operationProperties: readonly ["delete", "get", "post"];
+type OperationProperties = typeof operationProperties[number];
+export interface StorageDecorator extends StrictOmit<ResourceDecorator, 'Action'> {
+    (options?: Storage.DecoratorOptions): 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);
+    Delete: (options?: Storage.DeleteEndpointOptions) => ((target: Object, propertyKey: 'delete') => void);
+    Get: (options?: Storage.GetEndpointOptions) => ((target: Object, propertyKey: 'get') => void);
+    Post: (options?: Storage.PostEndpointOptions) => ((target: Object, propertyKey: 'post') => void);
+}
+export declare function StorageDecorator(options?: Storage.DecoratorOptions): ClassDecorator;
+export declare namespace StorageDecorator {
+    var Delete: (options?: unknown) => (target: Object, propertyKey: string | symbol) => void;
+    var Get: (options?: unknown) => (target: Object, propertyKey: string | symbol) => void;
+    var Post: (options?: unknown) => (target: Object, propertyKey: string | symbol) => void;
+    var Action: (options: any) => PropertyDecorator;
+}
+export {};

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

@@ -1,14 +1,15 @@
-import { StrictOmit, Type } from 'ts-gems';
+import { StrictOmit } from 'ts-gems';
 import { OpraSchema } from '../../schema/index.js';
 import type { ApiDocument } from '../api-document.js';
-import { Resource } from './resource.js';
+import type { Resource } from './resource.js';
+import { StorageClass } from './storage-class.js';
+import { StorageDecorator } from './storage-decorator.js';
 export declare namespace Storage {
     interface InitArguments extends Resource.InitArguments, StrictOmit<OpraSchema.Storage, 'kind'> {
     }
     interface DecoratorOptions extends Resource.DecoratorOptions {
     }
-    interface Metadata extends OpraSchema.Storage {
-        name: string;
+    interface Metadata extends StrictOmit<Resource.Metadata, 'kind'>, OpraSchema.Storage {
     }
     namespace Delete {
     }
@@ -16,26 +17,14 @@ export declare namespace Storage {
     }
     namespace Post {
     }
-    type DeleteOperationOptions = OpraSchema.Storage.DeleteOperation;
-    type GetOperationOptions = OpraSchema.Storage.GetOperation;
-    type PostOperationOptions = OpraSchema.Storage.PostOperation;
+    type DeleteEndpointOptions = OpraSchema.Storage.DeleteEndpoint;
+    type GetEndpointOptions = OpraSchema.Storage.GetEndpoint;
+    type PostEndpointOptions = OpraSchema.Storage.PostEndpoint;
 }
-declare class StorageClass extends Resource {
-    readonly kind = "Storage";
-    readonly operations: OpraSchema.Storage.Operations;
-    readonly controller?: object | Type;
-    constructor(document: ApiDocument, init: Storage.InitArguments);
-    exportSchema(): OpraSchema.Storage;
-}
-export interface StorageConstructor {
+export interface StorageConstructor extends StorageDecorator {
     prototype: Storage;
     new (document: ApiDocument, init: Storage.InitArguments): Storage;
-    (options?: Storage.DecoratorOptions): ClassDecorator;
-    Delete: (options?: Storage.DeleteOperationOptions) => ((target: Object, propertyKey: 'delete') => void);
-    Get: (options?: Storage.GetOperationOptions) => ((target: Object, propertyKey: 'get') => void);
-    Post: (options?: Storage.PostOperationOptions) => ((target: Object, propertyKey: 'post') => void);
 }
 export interface Storage extends StorageClass {
 }
 export declare const Storage: StorageConstructor;
-export {};

package/types/document/utils/generate-codec.d.ts

@@ -7,4 +7,4 @@ export interface GenerateDecoderOptions {
     partial?: boolean;
 }
 export declare function generateCodec(type: ComplexType, codec: 'decode' | 'encode', options: GenerateDecoderOptions): vg.Validator<any, any>;
-export declare function _generateDecoder(type: ComplexType | MappedType | UnionType, codec: 'decode' | 'encode', options: GenerateDecoderOptions): vg.Validator<any, any>;
+export declare function _generateCodec(type: ComplexType | MappedType | UnionType, codec: 'decode' | 'encode', options: GenerateDecoderOptions): vg.Validator<any, any>;

package/types/helpers/mixin-utils.d.ts

@@ -1,3 +1,3 @@
 import { Type } from 'ts-gems';
 export declare function mergePrototype(targetProto: any, baseProto: any, filter?: (k: string) => boolean): void;
-export declare function inheritPropertyInitializers(target: Record<string, any>, sourceClass: Type, isPropertyInherited?: (key: string) => boolean): void;
+export declare function inheritPropertyInitializers(target: Record<string, any>, clazz: Type, isPropertyInherited?: (key: string) => boolean): void;

package/types/schema/document.interface.d.ts

@@ -1,6 +1,6 @@
 import type { SpecVersion } from './constants.js';
 import type { DataType } from './data-type/data-type.interface.js';
-import type { Resource } from './resource/resource.interface.js';
+import type { Resource } from './resource/resource.interface';
 export interface ApiDocument {
     version: SpecVersion;
     url?: string;

package/types/schema/opra-schema.ns.d.ts

@@ -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/types/schema/resource/collection.interface.d.ts

@@ -1,8 +1,7 @@
 import type { OpraFilter } from '../../filter/index.js';
 import type { DataType } from '../data-type/data-type.interface.js';
 import type { Field } from '../data-type/field.interface';
-import type { Operation } from './operation.interface';
-import type { ResourceBase } from './resource.interface.js';
+import type { Endpoint, ResourceBase } from './resource.interface.js';
 export interface Collection extends ResourceBase {
     kind: Collection.Kind;
     type: DataType.Name;
@@ -12,40 +11,40 @@ export interface Collection extends ResourceBase {
 export declare namespace Collection {
     const Kind = "Collection";
     type Kind = 'Collection';
-    type CreateOperation = Operation & _OperationInput & _OperationResponse;
-    type DeleteOperation = Operation;
-    type DeleteManyOperation = Operation & _OperationFilter;
-    type GetOperation = Operation & _OperationResponse;
-    type FindManyOperation = Operation & _OperationFilter & _OperationResponse & {
+    type CreateEndpoint = Endpoint & _EndpointInput & _EndpointResponse;
+    type DeleteEndpoint = Endpoint;
+    type DeleteManyEndpoint = Endpoint & _EndpointFilter;
+    type GetEndpoint = Endpoint & _EndpointResponse;
+    type FindManyEndpoint = Endpoint & _EndpointFilter & _EndpointResponse & {
         sortFields?: string[];
         defaultSort?: string[];
     };
-    type UpdateOperation = Operation & _OperationInput & _OperationResponse;
-    type UpdateManyOperation = Operation & _OperationInput & _OperationFilter;
+    type UpdateEndpoint = Endpoint & _EndpointInput & _EndpointResponse;
+    type UpdateManyEndpoint = Endpoint & _EndpointInput & _EndpointFilter;
     interface Operations {
-        create?: CreateOperation;
-        delete?: DeleteOperation;
-        get?: GetOperation;
-        update?: UpdateOperation;
-        deleteMany?: DeleteManyOperation;
-        findMany?: FindManyOperation;
-        updateMany?: UpdateManyOperation;
+        create?: CreateEndpoint;
+        delete?: DeleteEndpoint;
+        get?: GetEndpoint;
+        update?: UpdateEndpoint;
+        deleteMany?: DeleteManyEndpoint;
+        findMany?: FindManyEndpoint;
+        updateMany?: UpdateManyEndpoint;
     }
 }
-interface _OperationFilter {
+interface _EndpointFilter {
     filters?: {
         field: Field.QualifiedName;
         operators?: OpraFilter.ComparisonOperator[];
     }[];
 }
-interface _OperationInput {
+interface _EndpointInput {
     input?: {
         maxContentSize?: number | string;
         pick?: Field.QualifiedName[];
         omit?: Field.QualifiedName[];
     };
 }
-interface _OperationResponse {
+interface _EndpointResponse {
     response?: {
         pick?: Field.QualifiedName[];
         omit?: Field.QualifiedName[];

package/types/schema/resource/container.interface.d.ts

@@ -1,7 +1,9 @@
-import type { Resource, ResourceBase } from './resource.interface.js';
+import type { DataType } from '../data-type/data-type.interface.js';
+import type { Resource, ResourceBase } from './resource.interface';
 export interface Container extends ResourceBase {
     kind: Container.Kind;
-    resources: Resource[];
+    types?: Record<DataType.Name, DataType>;
+    resources?: Record<Resource.Name, Resource>;
 }
 export declare namespace Container {
     const Kind = "Container";

package/types/schema/resource/resource.interface.d.ts

@@ -1,3 +1,4 @@
+import type { Field } from '../data-type/field.interface.js';
 import type { Collection } from './collection.interface.js';
 import type { Container } from './container.interface.js';
 import type { Singleton } from './singleton.interface.js';
@@ -10,4 +11,17 @@ export declare namespace Resource {
 export interface ResourceBase {
     kind: string;
     description?: string;
+    actions?: Record<Action.Name, Action>;
+}
+export interface Endpoint {
+    description?: string;
+}
+export interface Action {
+    parameters?: Record<Action.ParameterName, Action.Parameter>;
+}
+export declare namespace Action {
+    type Name = string;
+    type ParameterName = string;
+    interface Parameter extends Pick<Field, 'type' | 'description' | 'isArray' | 'default' | 'required' | 'deprecated' | 'examples'> {
+    }
 }

package/types/schema/resource/singleton.interface.d.ts

@@ -9,14 +9,14 @@ export interface Singleton extends ResourceBase {
 export declare namespace Singleton {
     const Kind = "Singleton";
     type Kind = 'Singleton';
-    type CreateOperation = Collection.CreateOperation;
-    type DeleteOperation = Collection.DeleteOperation;
-    type GetOperation = Collection.GetOperation;
-    type UpdateOperation = Collection.UpdateOperation;
+    type CreateEndpoint = Collection.CreateEndpoint;
+    type DeleteEndpoint = Collection.DeleteEndpoint;
+    type GetEndpoint = Collection.GetEndpoint;
+    type UpdateEndpoint = Collection.UpdateEndpoint;
     interface Operations {
-        create?: CreateOperation;
-        delete?: DeleteOperation;
-        get?: GetOperation;
-        update?: UpdateOperation;
+        create?: CreateEndpoint;
+        delete?: DeleteEndpoint;
+        get?: GetEndpoint;
+        update?: UpdateEndpoint;
     }
 }

package/types/schema/resource/storage.interface.d.ts

@@ -1,5 +1,4 @@
-import type { Operation } from './operation.interface';
-import type { ResourceBase } from './resource.interface.js';
+import type { Endpoint, ResourceBase } from './resource.interface.js';
 export interface Storage extends ResourceBase {
     kind: Storage.Kind;
     operations: Storage.Operations;
@@ -7,9 +6,9 @@ export interface Storage extends ResourceBase {
 export declare namespace Storage {
     const Kind = "Storage";
     type Kind = 'Storage';
-    type DeleteOperation = Operation;
-    type GetOperation = Operation;
-    type PostOperation = Operation & {
+    type DeleteEndpoint = Endpoint;
+    type GetEndpoint = Endpoint;
+    type PostEndpoint = Endpoint & {
         /**
          * the minium size of uploaded file
          *
@@ -48,8 +47,8 @@ export declare namespace Storage {
         maxFieldsSize?: number | undefined;
     };
     interface Operations {
-        delete?: DeleteOperation;
-        get?: GetOperation;
-        post?: PostOperation;
+        delete?: DeleteEndpoint;
+        get?: GetEndpoint;
+        post?: PostEndpoint;
     }
 }

package/types/schema/type-guards.d.ts

@@ -14,7 +14,7 @@ export declare function isSimpleType(obj: any): obj is SimpleType;
 export declare function isUnionType(obj: any): obj is UnionType;
 export declare function isMappedType(obj: any): obj is MappedType;
 export declare function isEnumType(obj: any): obj is EnumType;
-export declare function isResource(obj: any): obj is Resource;
+export declare function isSource(obj: any): obj is Resource;
 export declare function isCollection(obj: any): obj is Collection;
 export declare function isSingleton(obj: any): obj is Singleton;
 export declare function isStorage(obj: any): obj is Singleton;

package/cjs/schema/resource/operation.interface.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/esm/schema/resource/operation.interface.js

@@ -1 +0,0 @@
-export {};

package/types/schema/resource/operation.interface.d.ts

@@ -1,3 +0,0 @@
-export interface Operation {
-    description?: string;
-}