@opra/core 0.0.5

package/esm/implementation/data-type/simple-type.js

@@ -0,0 +1,26 @@
+import { colorFgMagenta, colorFgYellow, colorReset, nodeInspectCustom } from '../../utils/terminal-utils.js';
+import { DataType } from './data-type.js';
+export class SimpleType extends DataType {
+    constructor(owner, args, base) {
+        super(owner, {
+            kind: 'SimpleType',
+            ...args
+        }, base);
+    }
+    get type() {
+        return this._args.type;
+    }
+    get format() {
+        return this._args.format;
+    }
+    get default() {
+        return this._args.default;
+    }
+    toString() {
+        return `[${Object.getPrototypeOf(this).constructor.name} ${this.name}]`;
+    }
+    [nodeInspectCustom]() {
+        return `[${colorFgYellow + Object.getPrototypeOf(this).constructor.name + colorReset}` +
+            ` ${colorFgMagenta + this.name + colorReset}]`;
+    }
+}

package/esm/implementation/execution-context.d.ts

@@ -0,0 +1,42 @@
+import { SearchParams } from '@opra/url';
+import { HttpStatus } from '../enums/index.js';
+import { ApiException } from '../exception/index.js';
+import { ExecutionQuery } from '../interfaces/execution-query.interface.js';
+import { IHttpAdapterContext } from '../interfaces/http-context.interface.js';
+import { HeadersObject } from '../utils/headers.js';
+import { OpraService } from './opra-service.js';
+export declare type ContextType = 'http' | 'ws' | 'rpc';
+export declare type ExecutionContextArgs = Pick<ExecutionContext, 'type' | 'service' | 'request' | 'response' | 'adapterContext' | 'userContext' | 'continueOnError'>;
+export declare class ExecutionContext {
+    readonly type: ContextType;
+    readonly service: OpraService;
+    readonly request: ExecutionRequest;
+    readonly response: ExecutionResponse;
+    readonly adapterContext: any;
+    userContext?: any;
+    continueOnError?: boolean;
+    constructor(args: ExecutionContextArgs);
+    switchToHttp(): IHttpAdapterContext;
+}
+export declare type ExecutionRequestArgs = Pick<ExecutionRequest, 'query' | 'parentValue'> & {
+    params?: SearchParams;
+    headers?: HeadersObject;
+    resultPath?: string;
+};
+export declare class ExecutionRequest {
+    readonly query: ExecutionQuery;
+    readonly params: SearchParams;
+    readonly headers: HeadersObject;
+    readonly parentValue?: any;
+    readonly resultPath: string;
+    constructor(args: ExecutionRequestArgs);
+}
+export declare type ExecutionResponseArgs = Pick<ExecutionResponse, 'status' | 'value' | 'total'>;
+export declare class ExecutionResponse {
+    headers: HeadersObject;
+    errors: ApiException[];
+    status?: HttpStatus;
+    value?: any;
+    total?: number;
+    constructor(args?: ExecutionResponseArgs);
+}

package/esm/implementation/execution-context.js

@@ -0,0 +1,43 @@
+import { OpraURLSearchParams } from '@opra/url';
+import { Headers } from '../utils/headers.js';
+export class ExecutionContext {
+    type;
+    service;
+    request;
+    response;
+    adapterContext;
+    userContext;
+    continueOnError;
+    constructor(args) {
+        Object.assign(this, args);
+    }
+    switchToHttp() {
+        if (this.type !== 'http')
+            throw new Error(`You can't access http context within an ${this.type} context`);
+        return this.adapterContext;
+    }
+}
+export class ExecutionRequest {
+    query;
+    params;
+    headers;
+    parentValue;
+    resultPath;
+    constructor(args) {
+        Object.assign(this, args);
+        this.params = this.params || new OpraURLSearchParams();
+        this.headers = this.headers || Headers.create();
+        this.resultPath = this.resultPath || '';
+    }
+}
+export class ExecutionResponse {
+    headers = Headers.create();
+    errors = [];
+    status;
+    value;
+    total;
+    constructor(args) {
+        if (args)
+            Object.assign(this, args);
+    }
+}

package/esm/implementation/opra-document.d.ts

@@ -0,0 +1,26 @@
+import { StrictOmit } from 'ts-gems';
+import { OpraSchema } from '@opra/schema';
+import { ResponsiveObject } from '../utils/responsive-object.js';
+import { nodeInspectCustom } from '../utils/terminal-utils.js';
+import { ComplexType } from './data-type/complex-type.js';
+import { DataType } from './data-type/data-type.js';
+import { EntityType } from './data-type/entity-type.js';
+import { SimpleType } from './data-type/simple-type.js';
+import { SchemaGenerator } from './schema-generator.js';
+export declare type OpraDocumentArgs = StrictOmit<OpraSchema.Document, 'version' | 'types'>;
+export declare class OpraDocument {
+    protected readonly _args: OpraDocumentArgs;
+    protected _types: ResponsiveObject<DataType>;
+    constructor(schema: OpraSchema.Document);
+    get name(): string;
+    get info(): OpraSchema.DocumentInfo;
+    get types(): Record<string, DataType>;
+    getDataType(name: string): DataType;
+    getComplexDataType(name: string): ComplexType;
+    getEntityDataType(name: string): EntityType;
+    getSimpleDataType(name: string): SimpleType;
+    toString(): string;
+    [nodeInspectCustom](): string;
+    static create(args: SchemaGenerator.GenerateDocumentArgs): Promise<OpraDocument>;
+    protected _addDataTypes(dataTypes: OpraSchema.DataType[]): void;
+}

package/esm/implementation/opra-document.js

@@ -0,0 +1,111 @@
+import _ from 'lodash';
+import { OpraSchema } from '@opra/schema';
+import { internalDataTypes } from '../utils/internal-data-types.js';
+import { Responsive } from '../utils/responsive-object.js';
+import { colorFgMagenta, colorFgYellow, colorReset, nodeInspectCustom } from '../utils/terminal-utils.js';
+import { ComplexType } from './data-type/complex-type.js';
+import { EntityType } from './data-type/entity-type.js';
+import { SimpleType } from './data-type/simple-type.js';
+import { SchemaGenerator } from './schema-generator.js';
+export class OpraDocument {
+    _args;
+    _types = Responsive();
+    constructor(schema) {
+        this._args = _.omit(schema, 'types');
+        if (schema.types)
+            this._addDataTypes(schema.types);
+    }
+    get name() {
+        return this._args.info?.title || '';
+    }
+    get info() {
+        return this._args.info;
+    }
+    get types() {
+        return this._types;
+    }
+    getDataType(name) {
+        const t = this.types[name];
+        if (!t)
+            throw new Error(`Data type "${name}" does not exists`);
+        return t;
+    }
+    getComplexDataType(name) {
+        const t = this.getDataType(name);
+        if (!(t instanceof ComplexType))
+            throw new Error(`Data type "${name}" is not a ComplexType`);
+        return t;
+    }
+    getEntityDataType(name) {
+        const t = this.getDataType(name);
+        if (!(t instanceof EntityType))
+            throw new Error(`Data type "${name}" is not an EntityType`);
+        return t;
+    }
+    getSimpleDataType(name) {
+        const t = this.getDataType(name);
+        if (!(t instanceof SimpleType))
+            throw new Error(`Data type "${name}" is not a SimpleType`);
+        return t;
+    }
+    toString() {
+        return `[${Object.getPrototypeOf(this).constructor.name} ${this.name}]`;
+    }
+    [nodeInspectCustom]() {
+        return `[${colorFgYellow + Object.getPrototypeOf(this).constructor.name + colorReset}` +
+            ` ${colorFgMagenta + this.name + colorReset}]`;
+    }
+    static async create(args) {
+        const schema = await SchemaGenerator.generateDocumentSchema(args);
+        return new OpraDocument(schema);
+    }
+    _addDataTypes(dataTypes) {
+        const recursiveSet = new Set();
+        const nameSet = new Set(dataTypes.map(x => x.name));
+        const processDataType = (schema) => {
+            if ((!internalDataTypes.has(schema.name) && !nameSet.has(schema.name)) || this.types[schema.name])
+                return;
+            if (recursiveSet.has(schema.name))
+                throw new TypeError(`Recursive dependency detected. ${Array.from(recursiveSet).join('>')}`);
+            recursiveSet.add(schema.name);
+            let baseType;
+            if (schema.base) {
+                if (!this.types[schema.base]) {
+                    const baseSchema = dataTypes.find(dt => dt.name.toLowerCase() === schema.base?.toLowerCase()) ||
+                        internalDataTypes.get(schema.base.toLowerCase());
+                    if (!baseSchema)
+                        throw new TypeError(`Base schema (${schema.base}) of data type "${schema.name}" does not exists`);
+                    baseType = processDataType(baseSchema);
+                }
+            }
+            let dataType;
+            if (OpraSchema.isSimpleType(schema)) {
+                if (baseType && !(baseType instanceof SimpleType))
+                    throw new TypeError(`Can't extend a SimpleType (${schema.name}) from a ComplexType "${baseType.name}"`);
+                dataType = new SimpleType(this, schema, baseType);
+            }
+            else if (OpraSchema.isComplexType(schema)) {
+                if (baseType && !(baseType instanceof ComplexType))
+                    throw new TypeError(`Can't extend a ComplexType (${schema.name}) from a SimpleType "${baseType.name}"`);
+                dataType = new ComplexType(this, schema, baseType);
+            }
+            else if (OpraSchema.isEntityType(schema)) {
+                if (baseType && !(baseType instanceof ComplexType))
+                    throw new TypeError(`Can't extend an EntityType (${schema.name}) from a SimpleType "${baseType.name}"`);
+                dataType = new EntityType(this, schema, baseType);
+            }
+            else
+                throw new TypeError(`Invalid data type schema`);
+            nameSet.delete(schema.name);
+            this.types[dataType.name] = dataType;
+            recursiveSet.delete(schema.name);
+            return dataType;
+        };
+        dataTypes.forEach(dataType => processDataType(dataType));
+        // Sort data types by name
+        const newTypes = Responsive();
+        Object.keys(this.types).sort()
+            .forEach(name => newTypes[name] = this.types[name]);
+        this._types = newTypes;
+    }
+}

package/esm/implementation/opra-service.d.ts

@@ -0,0 +1,19 @@
+import { StrictOmit } from 'ts-gems';
+import { OpraSchema } from '@opra/schema';
+import { IResourceContainer } from '../interfaces/resource-container.interface.js';
+import { OpraDocument } from './opra-document.js';
+import { EntityResourceInfo } from './resource/entity-resource-info.js';
+import { ResourceInfo } from './resource/resource-info.js';
+import { SchemaGenerator } from './schema-generator.js';
+export declare type OpraServiceArgs = StrictOmit<OpraSchema.Service, 'version' | 'types' | 'resources'>;
+export declare class OpraService extends OpraDocument implements IResourceContainer {
+    protected readonly _args: OpraServiceArgs;
+    protected _resources: import("../utils/responsive-object.js").ResponsiveObject<ResourceInfo>;
+    constructor(schema: OpraSchema.Service);
+    get resources(): Record<string, ResourceInfo>;
+    get servers(): OpraSchema.ServerInfo[] | undefined;
+    getResource<T extends ResourceInfo>(name: string): T;
+    getEntityResource(name: string): EntityResourceInfo;
+    protected _addResources(resources: OpraSchema.Resource[]): void;
+    static create(args: SchemaGenerator.GenerateServiceArgs): Promise<OpraService>;
+}

package/esm/implementation/opra-service.js

@@ -0,0 +1,55 @@
+import { OpraSchema } from '@opra/schema';
+import { Responsive } from '../utils/responsive-object.js';
+import { EntityType } from './data-type/entity-type.js';
+import { OpraDocument } from './opra-document.js';
+import { EntityResourceInfo } from './resource/entity-resource-info.js';
+import { SchemaGenerator } from './schema-generator.js';
+export class OpraService extends OpraDocument {
+    _resources = Responsive();
+    constructor(schema) {
+        super(schema);
+        if (schema.resources)
+            this._addResources(schema.resources);
+    }
+    get resources() {
+        return this._resources;
+    }
+    get servers() {
+        return this._args.servers;
+    }
+    getResource(name) {
+        const t = this.resources[name];
+        if (!t)
+            throw new Error(`Resource "${name}" does not exists`);
+        return t;
+    }
+    getEntityResource(name) {
+        const t = this.getResource(name);
+        if (!(t instanceof EntityResourceInfo))
+            throw new Error(`"${name}" is not an EntityResource`);
+        return t;
+    }
+    _addResources(resources) {
+        for (const r of resources) {
+            if (OpraSchema.isEntityResource(r)) {
+                const dataType = this.getDataType(r.type);
+                if (!dataType)
+                    throw new TypeError(`Datatype "${r.type}" declared in EntityResource (${r.name}) does not exists`);
+                if (!(dataType instanceof EntityType))
+                    throw new TypeError(`${r.type} is not an EntityType`);
+                this.resources[r.name] = new EntityResourceInfo({ ...r, service: this, dataType });
+            }
+            else
+                throw new TypeError(`Unknown resource kind (${r.kind})`);
+        }
+        // Sort data types by name
+        const newResources = Responsive();
+        Object.keys(this.resources).sort()
+            .forEach(name => newResources[name] = this.resources[name]);
+        this._resources = newResources;
+    }
+    static async create(args) {
+        const schema = await SchemaGenerator.generateServiceSchema(args);
+        return new OpraService(schema);
+    }
+}

package/esm/implementation/resource/container-resource-controller.d.ts

@@ -0,0 +1,12 @@
+import { StrictOmit } from 'ts-gems';
+import { OpraSchema } from '@opra/schema';
+import { IResourceContainer } from '../../interfaces/resource-container.interface.js';
+import { EntityResourceInfo } from './entity-resource-info.js';
+import { ResourceInfo } from './resource-info.js';
+export declare type ContainerResourceControllerArgs = StrictOmit<OpraSchema.ContainerResource, 'kind'> & {};
+export declare class ContainerResourceController extends ResourceInfo implements IResourceContainer {
+    protected readonly _args: OpraSchema.ContainerResource;
+    constructor(args: ContainerResourceControllerArgs);
+    getResource<T extends ResourceInfo>(name: string): T;
+    getEntityResource(name: string): EntityResourceInfo;
+}

package/esm/implementation/resource/container-resource-controller.js

@@ -0,0 +1,22 @@
+import { EntityResourceInfo } from './entity-resource-info.js';
+import { ResourceInfo } from './resource-info.js';
+export class ContainerResourceController extends ResourceInfo {
+    constructor(args) {
+        super({
+            kind: 'ContainerResource',
+            ...args
+        });
+    }
+    getResource(name) {
+        const t = this._args.resources[name];
+        if (!t)
+            throw new Error(`Resource "${name}" does not exists`);
+        return t;
+    }
+    getEntityResource(name) {
+        const t = this.getResource(name);
+        if (!(t instanceof EntityResourceInfo))
+            throw new Error(`"${name}" is not an EntityResource`);
+        return t;
+    }
+}

package/esm/implementation/resource/entity-resource-info.d.ts

@@ -0,0 +1,24 @@
+import { Maybe, StrictOmit } from 'ts-gems';
+import { OpraSchema } from '@opra/schema';
+import { EntityType } from '../data-type/entity-type.js';
+import { ExecutionContext } from '../execution-context.js';
+import { OpraService } from '../opra-service.js';
+import { ResourceInfo } from './resource-info.js';
+export declare type EntityResourceControllerArgs = StrictOmit<OpraSchema.EntityResource, 'kind'> & {
+    service: OpraService;
+    dataType: EntityType;
+};
+export declare class EntityResourceInfo extends ResourceInfo {
+    protected readonly _args: OpraSchema.EntityResource;
+    readonly service: OpraService;
+    readonly dataType: EntityType;
+    constructor(args: EntityResourceControllerArgs);
+    get search(): Maybe<Function>;
+    get create(): Maybe<Function>;
+    get read(): Maybe<Function>;
+    get update(): Maybe<Function>;
+    get updateAll(): Maybe<Function>;
+    get delete(): Maybe<Function>;
+    get deleteMany(): Maybe<Function>;
+    execute(ctx: ExecutionContext): Promise<void>;
+}

package/esm/implementation/resource/entity-resource-info.js

@@ -0,0 +1,63 @@
+import _ from 'lodash';
+import { EntityType } from '../data-type/entity-type.js';
+import { ResourceInfo } from './resource-info.js';
+export class EntityResourceInfo extends ResourceInfo {
+    service;
+    dataType;
+    constructor(args) {
+        super({
+            kind: 'EntityResource',
+            ..._.omit(args, ['dataType', 'service'])
+        });
+        this.dataType = args.dataType;
+        this.service = args.service;
+        // noinspection SuspiciousTypeOfGuard
+        if (!(args.dataType instanceof EntityType))
+            throw new TypeError(`You should provide an EntityType for EntityResourceController`);
+    }
+    get search() {
+        return this._args.search;
+    }
+    get create() {
+        return this._args.create;
+    }
+    get read() {
+        return this._args.read;
+    }
+    get update() {
+        return this._args.update;
+    }
+    get updateAll() {
+        return this._args.updateMany;
+    }
+    get delete() {
+        return this._args.delete;
+    }
+    get deleteMany() {
+        return this._args.deleteMany;
+    }
+    async execute(ctx) {
+        const { query } = ctx.request;
+        const fn = this._args[query.queryType];
+        const result = typeof fn === 'function' ? (await fn(ctx)) : undefined;
+        if (query.queryType === 'search') {
+            ctx.response.value = Array.isArray(result)
+                ? result
+                : (ctx.response.value ? [result] : []);
+        }
+        else if (query.queryType === 'delete' ||
+            query.queryType === 'deleteMany' ||
+            query.queryType === 'updateMany') {
+            let affected = result;
+            if (affected && typeof affected === 'object')
+                affected = result.affected || result.affectedRows;
+            affected = typeof affected === 'number' ? affected :
+                (affected === false ? 0 : (affected ? 1 : 0));
+            ctx.response.value = {
+                affected
+            };
+        }
+        else
+            ctx.response.value = Array.isArray(result) ? result[0] : result;
+    }
+}

package/esm/implementation/resource/resource-info.d.ts

@@ -0,0 +1,10 @@
+import { OpraSchema } from '@opra/schema';
+import { nodeInspectCustom } from '../../utils/terminal-utils.js';
+export declare abstract class ResourceInfo {
+    protected readonly _args: OpraSchema.Resource;
+    protected constructor(args: OpraSchema.Resource);
+    get name(): string;
+    get description(): string | undefined;
+    toString(): string;
+    [nodeInspectCustom](): string;
+}

package/esm/implementation/resource/resource-info.js

@@ -0,0 +1,20 @@
+import { colorFgMagenta, colorFgYellow, colorReset, nodeInspectCustom } from '../../utils/terminal-utils.js';
+export class ResourceInfo {
+    _args;
+    constructor(args) {
+        this._args = args;
+    }
+    get name() {
+        return this._args.name;
+    }
+    get description() {
+        return this._args.description;
+    }
+    toString() {
+        return `[${Object.getPrototypeOf(this).constructor.name} ${this.name}]`;
+    }
+    [nodeInspectCustom]() {
+        return `[${colorFgYellow + Object.getPrototypeOf(this).constructor.name + colorReset}` +
+            ` ${colorFgMagenta + this.name + colorReset}]`;
+    }
+}

package/esm/implementation/schema-generator.d.ts

@@ -0,0 +1,21 @@
+import { StrictOmit, Type } from 'ts-gems';
+import { OpraSchema } from '@opra/schema';
+import { ThunkAsync } from '../types.js';
+export declare namespace SchemaGenerator {
+    type GenerateDocumentArgs = StrictOmit<OpraSchema.Document, 'version' | 'types'> & {
+        types?: ThunkAsync<Type | OpraSchema.DataType>[];
+    };
+    type GenerateServiceArgs = StrictOmit<OpraSchema.Service, 'version' | 'types' | 'resources'> & {
+        types?: ThunkAsync<Type | OpraSchema.DataType>[];
+        resources: any[];
+    };
+}
+export declare class SchemaGenerator {
+    protected _dataTypes: Record<string, OpraSchema.DataType>;
+    protected _resources: Record<string, OpraSchema.Resource>;
+    protected constructor();
+    protected addDataType(thunk: ThunkAsync<Type | OpraSchema.DataType>): Promise<OpraSchema.DataType>;
+    addResource(instance: any): Promise<void>;
+    static generateDocumentSchema(args: SchemaGenerator.GenerateDocumentArgs): Promise<OpraSchema.Document>;
+    static generateServiceSchema(args: SchemaGenerator.GenerateServiceArgs): Promise<OpraSchema.Service>;
+}