@opra/core 0.3.0 → 0.4.0

package/cjs/interfaces/entity-service.interface.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityResourceController = void 0;
-class EntityResourceController {
-    async search(ctx) {
-        return (await this.getService(ctx)).processRequest(ctx);
-    }
-    async get(ctx) {
-        return (await this.getService(ctx)).processRequest(ctx);
-    }
-    async count(ctx) {
-        return (await this.getService(ctx)).processRequest(ctx);
-    }
-    async create(ctx) {
-        return (await this.getService(ctx)).processRequest(ctx);
-    }
-    async update(ctx) {
-        return (await this.getService(ctx)).processRequest(ctx);
-    }
-    async updateMany(ctx) {
-        return (await this.getService(ctx)).processRequest(ctx);
-    }
-    async delete(ctx) {
-        return (await this.getService(ctx)).processRequest(ctx);
-    }
-    async deleteMany(ctx) {
-        return (await this.getService(ctx)).processRequest(ctx);
-    }
-}
-exports.EntityResourceController = EntityResourceController;

package/esm/implementation/adapter-utils/entity-resource-execute.util.d.ts

@@ -1,3 +0,0 @@
-import { EntityResource, OpraApi } from '@opra/schema';
-import { QueryContext } from '../query-context.js';
-export declare function entityResourceExecute(service: OpraApi, resource: EntityResource, context: QueryContext): Promise<void>;

package/esm/implementation/adapter-utils/entity-resource-execute.util.js

@@ -1,82 +0,0 @@
-import { ForbiddenError, ResourceNotFoundError } from '@opra/exception';
-import { translate } from '@opra/i18n';
-import { ComplexType, OpraCountCollectionQuery } from '@opra/schema';
-import { HttpHeaders } from '../../enums/index.js';
-export async function entityResourceExecute(service, resource, context) {
-    const { query } = context;
-    if (query.kind === 'SearchCollectionQuery') {
-        const promises = [];
-        let search;
-        promises.push(executeFn(service, resource, context)
-            .then(v => search = v));
-        if (query.count && resource.metadata.methods.count) {
-            const ctx = {
-                query: new OpraCountCollectionQuery(query.resource, { filter: query.filter }),
-                resultPath: ''
-            };
-            Object.setPrototypeOf(ctx, context);
-            promises.push(executeFn(service, resource, ctx));
-        }
-        await Promise.all(promises);
-        context.response = search;
-        return;
-    }
-    context.response = await executeFn(service, resource, context);
-}
-async function executeFn(service, resource, context) {
-    const method = context.query.method;
-    const resolverInfo = resource.metadata.methods?.[method];
-    if (!(resolverInfo && resolverInfo.handler))
-        throw new ForbiddenError({
-            message: translate('RESOLVER_FORBIDDEN', { method }, `The resource endpoint does not accept '{{method}}' operations`),
-            severity: 'error',
-            code: 'RESOLVER_FORBIDDEN'
-        });
-    let result = await resolverInfo.handler(context);
-    switch (method) {
-        case 'search':
-            const items = Array.isArray(result) ? result : (context.response ? [result] : []);
-            context.responseHeaders.set(HttpHeaders.X_Opra_Schema, resource.dataType.name);
-            return items;
-        case 'get':
-        case 'update':
-            if (!result) {
-                const query = context.query;
-                throw new ResourceNotFoundError(resource.name, query.keyValue);
-            }
-            break;
-        case 'count':
-            context.responseHeaders.set(HttpHeaders.X_Opra_Count, result);
-            return;
-        case 'delete':
-        case 'deleteMany':
-        case 'updateMany':
-            let affected;
-            if (typeof result === 'number')
-                affected = result;
-            if (typeof result === 'boolean')
-                affected = result ? 1 : 0;
-            if (typeof result === 'object')
-                affected = result.affectedRows || result.affected;
-            return {
-                operation: context.query.method,
-                affected
-            };
-    }
-    if (!result)
-        return;
-    result = Array.isArray(result) ? result[0] : result;
-    let dataType = resource.dataType;
-    if (context.resultPath) {
-        const pathArray = context.resultPath.split('.');
-        for (const field of pathArray) {
-            const prop = dataType instanceof ComplexType ? dataType.fields.get(field) : undefined;
-            dataType = prop && prop.type ? service.types.get(prop.type) : undefined;
-            result = result && typeof result === 'object' && result[field];
-        }
-    }
-    if (method === 'create')
-        context.status = 201;
-    context.responseHeaders.set(HttpHeaders.X_Opra_Schema, resource.dataType.name);
-    return result;
-}

package/esm/implementation/adapter-utils/resource-execute.util.d.ts

@@ -1,3 +0,0 @@
-import { OpraApi, OpraResource } from '@opra/schema';
-import { QueryContext } from '../query-context.js';
-export declare function resourceExecute(service: OpraApi, resource: OpraResource, context: QueryContext): Promise<void>;

package/esm/implementation/adapter-utils/resource-execute.util.js

@@ -1,7 +0,0 @@
-import { EntityResource } from '@opra/schema';
-import { entityResourceExecute } from './entity-resource-execute.util.js';
-export async function resourceExecute(service, resource, context) {
-    if (resource instanceof EntityResource)
-        return await entityResourceExecute(service, resource, context);
-    throw new Error(`Executing "${resource.kind}" has not been implemented yet`);
-}

package/esm/implementation/adapter-utils/resource-prepare.util.d.ts

@@ -1,3 +0,0 @@
-import { OpraResource } from '@opra/schema';
-import { QueryContext } from '../query-context.js';
-export declare function resourcePrepare(resource: OpraResource, context: QueryContext): Promise<void>;

package/esm/implementation/adapter-utils/resource-prepare.util.js

@@ -1,7 +0,0 @@
-export async function resourcePrepare(resource, context) {
-    const { query } = context;
-    const fn = resource.metadata['pre_' + query.method];
-    if (fn && typeof fn === 'function') {
-        await fn(context);
-    }
-}

package/esm/implementation/adapter.js

@@ -1,126 +0,0 @@
-import { AsyncEventEmitter } from 'strict-typed-events';
-import { BadRequestError, FailedDependencyError, wrapException } from '@opra/exception';
-import { I18n } from '@opra/i18n';
-import { createI18n } from '../utils/create-i18n.js';
-import { resourceExecute } from './adapter-utils/resource-execute.util.js';
-import { resourcePrepare } from './adapter-utils/resource-prepare.util.js';
-export class OpraAdapter {
-    service;
-    i18n;
-    userContextResolver;
-    constructor(service, options) {
-        this.service = service;
-        this.i18n = options?.i18n || I18n.defaultInstance;
-        this.userContextResolver = options?.userContext;
-    }
-    async handler(executionContext) {
-        if (!this.i18n.isInitialized)
-            await this.i18n.init();
-        let queryContexts;
-        let userContext;
-        let failed = false;
-        try {
-            queryContexts = this.prepareRequests(executionContext);
-            let stop = false;
-            // Read requests can be executed simultaneously, write request should be executed one by one
-            let promises;
-            let exclusive = false;
-            for (const context of queryContexts) {
-                exclusive = exclusive || context.query.operation !== 'read';
-                // Wait previous read requests before executing update request
-                if (exclusive && promises) {
-                    await Promise.allSettled(promises);
-                    promises = undefined;
-                }
-                // If previous request in bucket had an error and executed an update
-                // we do not execute next requests
-                if (stop) {
-                    context.errors.push(new FailedDependencyError());
-                    continue;
-                }
-                try {
-                    const promise = (async () => {
-                        if (context.query.method === 'metadata') {
-                            await this._getSchemaExecute(context);
-                            return;
-                        }
-                        const resource = context.query.resource;
-                        await resourcePrepare(resource, context);
-                        if (this.userContextResolver && !userContext)
-                            userContext = this.userContextResolver({
-                                executionContext,
-                                isBatch: this.isBatch(executionContext)
-                            });
-                        context.userContext = userContext;
-                        await resourceExecute(this.service, resource, context);
-                    })().catch(e => {
-                        context.errors.push(e);
-                    });
-                    if (exclusive)
-                        await promise;
-                    else {
-                        promises = promises || [];
-                        promises.push(promise);
-                    }
-                    // todo execute sub property queries
-                }
-                catch (e) {
-                    context.errors.unshift(e);
-                }
-                if (context.errors.length) {
-                    // noinspection SuspiciousTypeOfGuard
-                    context.errors = context.errors.map(e => wrapException(e));
-                    if (exclusive)
-                        stop = stop || !!context.errors.find(e => !(e.issue.severity === 'warning' || e.issue.severity === 'info'));
-                }
-            }
-            if (promises)
-                await Promise.allSettled(promises);
-            await this.sendResponse(executionContext, queryContexts);
-        }
-        catch (e) {
-            failed = true;
-            const error = wrapException(e);
-            await this.sendError(executionContext, error);
-        }
-        finally {
-            if (executionContext instanceof AsyncEventEmitter) {
-                await executionContext
-                    .emitAsyncSerial('finish', {
-                    userContext,
-                    failed
-                }).catch();
-            }
-        }
-    }
-    async _getSchemaExecute(ctx) {
-        const query = ctx.query;
-        let out;
-        if (query.resourcePath && query.resourcePath.length > 2)
-            throw new BadRequestError();
-        if (query.resourcePath?.length) {
-            if (query.resourcePath[0] === 'resources') {
-                const resource = this.service.getResource(query.resourcePath[1]);
-                out = resource.getSchema(true);
-                query.resourcePath[1] = resource.name;
-            }
-            else if (query.resourcePath[0] === 'types') {
-                const dataType = this.service.getDataType(query.resourcePath[1]);
-                out = dataType.getSchema(true);
-                query.resourcePath[1] = dataType.name;
-            }
-            else
-                throw new BadRequestError();
-            ctx.response = out;
-            return;
-        }
-        ctx.response = this.service.getSchema(true);
-    }
-    static async initI18n(options) {
-        if (options?.i18n instanceof I18n)
-            return options.i18n;
-        if (typeof options?.i18n === 'function')
-            return options.i18n();
-        return createI18n(options?.i18n);
-    }
-}

package/esm/implementation/http-adapter.js

@@ -1,249 +0,0 @@
-import { BadRequestError, InternalServerError, IssueSeverity, MethodNotAllowedError, NotFoundError, OpraException, wrapException } from '@opra/exception';
-import { ComplexType, ContainerResource, EntityResource, OpraCreateInstanceQuery, OpraDeleteCollectionQuery, OpraDeleteInstanceQuery, OpraGetFieldQuery, OpraGetInstanceQuery, OpraGetMetadataQuery, OpraSchema, OpraSearchCollectionQuery, OpraUpdateCollectionQuery, OpraUpdateInstanceQuery, } from '@opra/schema';
-import { OpraURL } from '@opra/url';
-import { HttpHeaders, HttpStatus } from '../enums/index.js';
-import { OpraAdapter } from './adapter.js';
-import { HeadersMap } from './headers-map.js';
-import { QueryContext } from './query-context.js';
-export class OpraHttpAdapter extends OpraAdapter {
-    prepareRequests(executionContext) {
-        const req = executionContext.getRequestWrapper();
-        // todo implement batch requests
-        if (this.isBatch(executionContext)) {
-            throw new Error('not implemented yet');
-        }
-        const url = new OpraURL(req.getUrl());
-        return [
-            this.prepareRequest(executionContext, url, req.getMethod(), new HeadersMap(req.getHeaders()), req.getBody())
-        ];
-    }
-    prepareRequest(executionContext, url, method, headers, body) {
-        if (!url.path.size)
-            throw new BadRequestError();
-        if (method !== 'GET' && url.path.size > 1)
-            throw new BadRequestError();
-        const query = this.buildQuery(url, method, body);
-        if (!query)
-            throw new MethodNotAllowedError({
-                message: `Method "${method}" is not allowed by target endpoint`
-            });
-        return new QueryContext({
-            service: this.service,
-            executionContext,
-            query,
-            headers: new HeadersMap(),
-            params: url.searchParams,
-            continueOnError: query.operation === 'read'
-        });
-    }
-    buildGGetMetadataQuery(url) {
-        const pathLen = url.path.size;
-        const resourcePath = [];
-        let pathIndex = 0;
-        while (pathIndex < pathLen) {
-            const p = url.path.get(pathIndex++);
-            if (p.key)
-                throw new BadRequestError();
-            if (p.resource !== '$metadata') {
-                if (pathIndex === 1)
-                    resourcePath.push('resources');
-                resourcePath.push(p.resource);
-            }
-        }
-        const opts = {
-            pick: url.searchParams.get('$pick'),
-            omit: url.searchParams.get('$omit'),
-            include: url.searchParams.get('$include'),
-            resourcePath
-        };
-        return new OpraGetMetadataQuery(opts);
-    }
-    buildQuery(url, method, body) {
-        let container = this.service;
-        try {
-            const pathLen = url.path.size;
-            // Check if requesting metadata
-            for (let i = 0; i < pathLen; i++) {
-                const p = url.path.get(i);
-                if (p.resource === '$metadata') {
-                    if (method !== 'GET')
-                        return;
-                    return this.buildGGetMetadataQuery(url);
-                }
-            }
-            let pathIndex = 0;
-            while (pathIndex < pathLen) {
-                let p = url.path.get(pathIndex++);
-                const resource = container.getResource(p.resource);
-                // Move through path directories (containers)
-                if (resource instanceof ContainerResource) {
-                    container = resource;
-                    continue;
-                }
-                method = method.toUpperCase();
-                if (resource instanceof EntityResource) {
-                    const scope = p.key ? 'instance' : 'collection';
-                    if (pathIndex < pathLen && !(method === 'GET' && scope === 'instance'))
-                        return;
-                    let query;
-                    switch (method) {
-                        case 'GET': {
-                            if (scope === 'collection') {
-                                query = new OpraSearchCollectionQuery(resource, {
-                                    filter: url.searchParams.get('$filter'),
-                                    limit: url.searchParams.get('$limit'),
-                                    skip: url.searchParams.get('$skip'),
-                                    distinct: url.searchParams.get('$distinct'),
-                                    count: url.searchParams.get('$count'),
-                                    sort: url.searchParams.get('$sort'),
-                                    pick: url.searchParams.get('$pick'),
-                                    omit: url.searchParams.get('$omit'),
-                                    include: url.searchParams.get('$include'),
-                                });
-                            }
-                            else {
-                                query = new OpraGetInstanceQuery(resource, p.key, {
-                                    pick: url.searchParams.get('$pick'),
-                                    omit: url.searchParams.get('$omit'),
-                                    include: url.searchParams.get('$include')
-                                });
-                                // Move through properties
-                                let dataType = resource.dataType;
-                                const curPath = [];
-                                let parent = query;
-                                while (pathIndex < pathLen) {
-                                    if (!(dataType instanceof ComplexType))
-                                        throw new TypeError(`"${resource.name}.${curPath.join()}" is not a ComplexType and has no fields.`);
-                                    p = url.path.get(pathIndex++);
-                                    curPath.push(p.resource);
-                                    const field = dataType.getField(p.resource);
-                                    parent.nested = new OpraGetFieldQuery(parent, field.name);
-                                    parent = parent.nested;
-                                    dataType = parent.dataType;
-                                }
-                            }
-                            break;
-                        }
-                        case 'DELETE': {
-                            query = scope === 'collection'
-                                ? new OpraDeleteCollectionQuery(resource, {
-                                    filter: url.searchParams.get('$filter'),
-                                })
-                                : new OpraDeleteInstanceQuery(resource, p.key);
-                            break;
-                        }
-                        case 'POST': {
-                            if (scope === 'collection') {
-                                query = new OpraCreateInstanceQuery(resource, body, {
-                                    pick: url.searchParams.get('$pick'),
-                                    omit: url.searchParams.get('$omit'),
-                                    include: url.searchParams.get('$include')
-                                });
-                            }
-                            break;
-                        }
-                        case 'PATCH': {
-                            query = scope === 'collection'
-                                ? new OpraUpdateCollectionQuery(resource, body, {
-                                    filter: url.searchParams.get('$filter')
-                                })
-                                : new OpraUpdateInstanceQuery(resource, p.key, body, {
-                                    pick: url.searchParams.get('$pick'),
-                                    omit: url.searchParams.get('$omit'),
-                                    include: url.searchParams.get('$include')
-                                });
-                            break;
-                        }
-                    }
-                    return query;
-                }
-            }
-            throw new InternalServerError();
-        }
-        catch (e) {
-            if (e instanceof OpraException)
-                throw e;
-            throw new BadRequestError(e);
-        }
-    }
-    async sendResponse(executionContext, queryContexts) {
-        const outputPackets = [];
-        for (const ctx of queryContexts) {
-            const v = this.createOutput(ctx);
-            outputPackets.push(v);
-        }
-        if (this.isBatch(executionContext)) {
-            // this.writeError([], new InternalServerError({message: 'Not implemented yet'}));
-            return;
-        }
-        if (!outputPackets.length)
-            return this.sendError(executionContext, new NotFoundError());
-        const out = outputPackets[0];
-        const resp = executionContext.getResponseWrapper();
-        resp.setStatus(out.status);
-        resp.setHeader(HttpHeaders.Content_Type, 'application/opra+json');
-        resp.setHeader(HttpHeaders.Cache_Control, 'no-cache');
-        resp.setHeader(HttpHeaders.Pragma, 'no-cache');
-        resp.setHeader(HttpHeaders.Expires, '-1');
-        resp.setHeader(HttpHeaders.X_Opra_Version, OpraSchema.Version);
-        if (out.headers) {
-            for (const [k, v] of Object.entries(out.headers)) {
-                resp.setHeader(k, v);
-            }
-        }
-        resp.send(JSON.stringify(out.body));
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    isBatch(executionContext) {
-        return false;
-    }
-    createOutput(ctx) {
-        const { query } = ctx;
-        let body;
-        let status = ctx.status || 0;
-        const errors = ctx.errors.map(e => wrapException(e));
-        if (errors && errors.length) {
-            // Sort errors from fatal to info
-            errors.sort((a, b) => {
-                const i = IssueSeverity.Keys.indexOf(a.issue.severity) - IssueSeverity.Keys.indexOf(b.issue.severity);
-                if (i === 0)
-                    return b.status - a.status;
-                return i;
-            });
-            if (!status || status < HttpStatus.BAD_REQUEST) {
-                status = errors[0].status;
-                if (status < HttpStatus.BAD_REQUEST)
-                    status = HttpStatus.INTERNAL_SERVER_ERROR;
-            }
-            body = {
-                operation: ctx.query.method,
-                errors: errors.map(e => e.issue)
-            };
-        }
-        else {
-            body = ctx.response;
-            status = status || (query.operation === 'create' ? HttpStatus.CREATED : HttpStatus.OK);
-        }
-        body = this.i18n.deep(body);
-        return {
-            status,
-            headers: ctx.responseHeaders.toObject(),
-            body
-        };
-    }
-    async sendError(executionContext, error) {
-        const resp = executionContext.getResponseWrapper();
-        resp.setStatus(error.status || 500);
-        resp.setHeader(HttpHeaders.Content_Type, 'application/json');
-        resp.setHeader(HttpHeaders.Cache_Control, 'no-cache');
-        resp.setHeader(HttpHeaders.Pragma, 'no-cache');
-        resp.setHeader(HttpHeaders.Expires, '-1');
-        resp.setHeader(HttpHeaders.X_Opra_Version, OpraSchema.Version);
-        const issue = this.i18n.deep(error.issue);
-        const body = {
-            operation: 'unknown',
-            errors: [issue]
-        };
-        resp.send(JSON.stringify(body));
-    }
-}

package/esm/interfaces/entity-service.interface.d.ts

@@ -1,19 +0,0 @@
-import { Maybe } from 'ts-gems';
-import { IResource, OpraResource } from '@opra/schema';
-import { EntityOutput } from '@sqb/connect';
-import { QueryContext } from '../implementation/query-context.js';
-export interface IEntityService {
-    processRequest(ctx: QueryContext): any;
-}
-export declare abstract class EntityResourceController<T, TOutput = EntityOutput<T>> implements IResource {
-    search(ctx: QueryContext): Promise<TOutput[]>;
-    get(ctx: QueryContext): Promise<Maybe<TOutput>>;
-    count(ctx: QueryContext): Promise<number>;
-    create(ctx: QueryContext): Promise<TOutput>;
-    update(ctx: QueryContext): Promise<Maybe<TOutput>>;
-    updateMany(ctx: QueryContext): Promise<Maybe<number>>;
-    delete(ctx: QueryContext): Promise<Maybe<boolean | number>>;
-    deleteMany(ctx: QueryContext): Promise<Maybe<number>>;
-    init?(service: OpraResource): void | Promise<void>;
-    abstract getService(ctx: QueryContext): IEntityService | Promise<IEntityService>;
-}

package/esm/interfaces/entity-service.interface.js

@@ -1,26 +0,0 @@
-export class EntityResourceController {
-    async search(ctx) {
-        return (await this.getService(ctx)).processRequest(ctx);
-    }
-    async get(ctx) {
-        return (await this.getService(ctx)).processRequest(ctx);
-    }
-    async count(ctx) {
-        return (await this.getService(ctx)).processRequest(ctx);
-    }
-    async create(ctx) {
-        return (await this.getService(ctx)).processRequest(ctx);
-    }
-    async update(ctx) {
-        return (await this.getService(ctx)).processRequest(ctx);
-    }
-    async updateMany(ctx) {
-        return (await this.getService(ctx)).processRequest(ctx);
-    }
-    async delete(ctx) {
-        return (await this.getService(ctx)).processRequest(ctx);
-    }
-    async deleteMany(ctx) {
-        return (await this.getService(ctx)).processRequest(ctx);
-    }
-}