@opra/common 0.25.4 → 0.26.0

package/types/document/decorators/singleton.decorator.d.ts

@@ -1,25 +0,0 @@
-import { StrictOmit } from 'ts-gems';
-import { TypeThunkAsync } from '../../types.js';
-import { Resource } from '../resource/resource.js';
-import type { Singleton } from '../resource/singleton.js';
-import { ResourceDecorator } from './resource.decorator.js';
-type ErrorMessage<T, Error> = [T] extends [never] ? Error : T;
-declare const operationProperties: readonly ["create", "delete", "get", "update"];
-type OperationProperties = typeof operationProperties[number];
-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 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 {};

package/types/document/decorators/storage.decorator.d.ts

@@ -1,22 +0,0 @@
-import { StrictOmit } from 'ts-gems';
-import { Resource } from '../resource/resource.js';
-import type { Storage } from '../resource/storage.js';
-import { ResourceDecorator } from './resource.decorator.js';
-type ErrorMessage<T, Error> = [T] extends [never] ? Error : T;
-declare const operationProperties: readonly ["delete", "get", "post"];
-type OperationProperties = typeof operationProperties[number];
-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 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 {};

package/types/document/factory/add-references.d.ts

@@ -1,4 +0,0 @@
-import type { OpraSchema } from '../../schema/index.js';
-import { ApiDocument } from '../api-document.js';
-import type { DocumentFactory } from './factory.js';
-export declare function addReferences(this: DocumentFactory, references: Record<string, string | OpraSchema.ApiDocument | ApiDocument>): Promise<void>;

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

@@ -1,12 +0,0 @@
-import { ApiDocument } from '../api-document.js';
-import type { DocumentFactory } from './factory.js';
-export declare function createDocument(this: DocumentFactory, init: DocumentFactory.InitArguments, options?: {
-    noBuiltinTypes?: boolean;
-}): Promise<ApiDocument>;
-/**
- *
- * @param url
- * @protected
- */
-export declare function createDocumentFromUrl(this: DocumentFactory, url: string): Promise<ApiDocument>;
-export declare function createBuiltinTypeDocument(this: DocumentFactory): Promise<ApiDocument>;

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

@@ -1,63 +0,0 @@
-import { StrictOmit, Type } from 'ts-gems';
-import { ResponsiveMap } from '../../helpers/index.js';
-import { OpraSchema } from '../../schema/index.js';
-import { ThunkAsync } from '../../types.js';
-import { ApiDocument } from '../api-document.js';
-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, createSingletonResource, createStorageResource, processSourceQueue } from './process-resources.js';
-import { addDataType, createDataTypeInstance, processTypes } from './process-types.js';
-/**
- * @namespace DocumentFactory
- */
-export declare namespace DocumentFactory {
-    interface InitArguments extends StrictOmit<OpraSchema.ApiDocument, 'references' | 'types' | 'resources'> {
-        references?: Record<string, string | OpraSchema.ApiDocument | ApiDocument>;
-        resources?: ThunkAsync<Type | object>[] | Record<OpraSchema.Resource.Name, OpraSchema.Resource>;
-        types?: ThunkAsync<Type | OpraSchema.EnumThunk>[] | Record<string, OpraSchema.DataType>;
-    }
-}
-/**
- * @class DocumentFactory
- */
-export declare class DocumentFactory {
-    static designTypeMap: Map<Function | Type<any>, string>;
-    protected document: ApiDocument;
-    protected typeQueue: ResponsiveMap<OpraSchema.DataType>;
-    protected sourceQueue: ResponsiveMap<OpraSchema.Resource>;
-    protected circularRefs: ResponsiveMap<any>;
-    protected curPath: string[];
-    protected cache: Map<any, any>;
-    protected createDocument: typeof createDocument;
-    protected createDocumentFromUrl: typeof createDocumentFromUrl;
-    protected createBuiltinTypeDocument: typeof createBuiltinTypeDocument;
-    protected addReferences: typeof addReferences;
-    protected importTypeClass: typeof importTypeClass;
-    protected extractSimpleTypeSchema: typeof extractSimpleTypeSchema;
-    protected extractComplexTypeSchema: typeof extractComplexTypeSchema;
-    protected extractMappedTypeSchema: typeof extractMappedTypeSchema;
-    protected extractUnionTypeSchema: typeof extractUnionTypeSchema;
-    protected extractEnumTypeSchema: typeof extractEnumTypeSchema;
-    protected extractFieldSchema: typeof extractFieldSchema;
-    protected processTypes: typeof processTypes;
-    protected createDataTypeInstance: typeof createDataTypeInstance;
-    protected addDataType: typeof addDataType;
-    protected importSourceClass: typeof importResourceClass;
-    protected extractSingletonSchema: typeof extractSingletonSchema;
-    protected extractCollectionSchema: typeof extractCollectionSchema;
-    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
-     */
-    static createDocument(init: DocumentFactory.InitArguments): Promise<ApiDocument>;
-    /**
-     * Downloads schema from the given URL and creates the document instance   * @param url
-     */
-    static createDocumentFromUrl(url: string): Promise<ApiDocument>;
-}

package/types/document/factory/import-resource-class.d.ts

@@ -1,10 +0,0 @@
-import 'reflect-metadata';
-import { Type } from 'ts-gems';
-import { OpraSchema } from '../../schema/index.js';
-import type { ThunkAsync } from '../../types.js';
-import type { Collection } from '../resource/collection.js';
-import type { Singleton } from '../resource/singleton.js';
-import type { DocumentFactory } from './factory.js';
-export declare function importResourceClass(this: DocumentFactory, thunk: ThunkAsync<Type | object>): Promise<void>;
-export declare function extractSingletonSchema(this: DocumentFactory, target: OpraSchema.Singleton, ctor: Type, metadata: Singleton.Metadata, controller: object | Type): Promise<void>;
-export declare function extractCollectionSchema(this: DocumentFactory, target: OpraSchema.Collection, ctor: Type, metadata: Collection.Metadata, controller: object | Type): Promise<void>;

package/types/document/factory/import-type-class.d.ts

@@ -1,17 +0,0 @@
-import { Type } from 'ts-gems';
-import { OpraSchema } from '../../schema/index.js';
-import type { ThunkAsync } from '../../types.js';
-import type { ComplexType } from '../data-type/complex-type.js';
-import type { EnumType } from '../data-type/enum-type.js';
-import type { ApiField } from '../data-type/field.js';
-import type { MappedType } from '../data-type/mapped-type.js';
-import type { SimpleType } from '../data-type/simple-type.js';
-import type { UnionType } from '../data-type/union-type.js';
-import type { DocumentFactory } from './factory.js';
-export declare function importTypeClass(this: DocumentFactory, typeThunk: ThunkAsync<Type | OpraSchema.EnumThunk>): Promise<string | OpraSchema.DataType>;
-export declare function extractSimpleTypeSchema(this: DocumentFactory, target: OpraSchema.SimpleType, ctor: Type, metadata: SimpleType.Metadata): Promise<void>;
-export declare function extractComplexTypeSchema(this: DocumentFactory, target: OpraSchema.ComplexType, ctor: Type, metadata: ComplexType.Metadata): Promise<void>;
-export declare function extractMappedTypeSchema(this: DocumentFactory, target: OpraSchema.MappedType, ctor: Type, metadata: MappedType.Metadata): Promise<void>;
-export declare function extractUnionTypeSchema(this: DocumentFactory, target: OpraSchema.UnionType, ctor: Type, metadata: UnionType.Metadata): Promise<void>;
-export declare function extractEnumTypeSchema(this: DocumentFactory, target: OpraSchema.EnumType, enumObject: any, metadata: EnumType.Metadata): Promise<void>;
-export declare function extractFieldSchema(this: DocumentFactory, target: OpraSchema.Field, ctor: Type, metadata: ApiField.Metadata, name: string): Promise<void>;

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

@@ -1 +0,0 @@
-export * from './factory.js';

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

@@ -1,9 +0,0 @@
-import { OpraSchema } from '../../schema/index.js';
-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 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 createStorageResource(this: DocumentFactory, name: string, schema: OpraSchema.Storage): Promise<Storage>;

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

@@ -1,6 +0,0 @@
-import { OpraSchema } from '../../schema/index.js';
-import { DataType } from '../data-type/data-type.js';
-import type { DocumentFactory } from './factory.js';
-export declare function processTypes(this: DocumentFactory): Promise<void>;
-export declare function createDataTypeInstance(this: DocumentFactory, kind: OpraSchema.DataType.Kind, name?: string): DataType;
-export declare function addDataType(this: DocumentFactory, schemaOrName: OpraSchema.DataType | string): DataType;

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

@@ -1,10 +0,0 @@
-import * as vg from 'valgen';
-import { ComplexType } from '../data-type/complex-type.js';
-import { MappedType } from '../data-type/mapped-type.js';
-import { UnionType } from '../data-type/union-type.js';
-export interface GenerateDecoderOptions {
-    omit?: string[];
-    partial?: boolean;
-}
-export declare function generateCodec(type: ComplexType, 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/schema/document.interface.d.ts

@@ -1,34 +0,0 @@
-import type { SpecVersion } from './constants.js';
-import type { DataType } from './data-type/data-type.interface.js';
-import type { Resource } from './resource/resource.interface';
-export interface ApiDocument {
-    version: SpecVersion;
-    url?: string;
-    info: DocumentInfo;
-    references?: Record<string, string | ApiDocument>;
-    types?: Record<DataType.Name, DataType>;
-    resources?: Record<Resource.Name, Resource>;
-    servers?: ServerInfo[];
-}
-export type DocumentInfo = {
-    title: string;
-    version: string;
-    description?: string;
-    termsOfService?: string;
-    contact?: ContactPerson[];
-    license?: LicenseInfo;
-};
-export type ServerInfo = {
-    url: string;
-    description?: string;
-};
-export type ContactPerson = {
-    name?: string;
-    email?: string;
-    url?: string;
-};
-export type LicenseInfo = {
-    name: string;
-    url?: string;
-    content?: string;
-};