@opra/core 0.1.1 → 0.3.0

package/esm/exception/http-errors/unprocessable-entity.error.js

@@ -1,21 +0,0 @@
-import { translate } from '@opra/i18n';
-import { HttpStatus } from '../../enums/index.js';
-import { ApiException } from '../api-exception.js';
-/**
- * 422 Unprocessable Entity
- * The request was well-formed but was unable to be followed due to semantic errors.
- */
-export class UnprocessableEntityError extends ApiException {
-    constructor(response, cause) {
-        super(response, cause);
-        this.status = HttpStatus.UNPROCESSABLE_ENTITY;
-    }
-    _initResponse(response) {
-        super._initResponse({
-            message: translate('error:UNPROCESSABLE_ENTITY'),
-            severity: 'error',
-            code: 'UNPROCESSABLE_ENTITY',
-            ...response
-        });
-    }
-}

package/esm/exception/index.d.ts

@@ -1,12 +0,0 @@
-export * from './api-exception.js';
-export * from './http-errors/bad-request.error.js';
-export * from './http-errors/failed-dependency.error.js';
-export * from './http-errors/forbidden.error.js';
-export * from './http-errors/internal-server.error.js';
-export * from './http-errors/method-not-allowed.error.js';
-export * from './http-errors/not-acceptable.error.js';
-export * from './http-errors/not-found.error.js';
-export * from './http-errors/unauthorized.error.js';
-export * from './http-errors/unprocessable-entity.error.js';
-export * from './resource-errors/resource-conflict.error.js';
-export * from './resource-errors/resource-not-found.error.js';

package/esm/exception/index.js

@@ -1,12 +0,0 @@
-export * from './api-exception.js';
-export * from './http-errors/bad-request.error.js';
-export * from './http-errors/failed-dependency.error.js';
-export * from './http-errors/forbidden.error.js';
-export * from './http-errors/internal-server.error.js';
-export * from './http-errors/method-not-allowed.error.js';
-export * from './http-errors/not-acceptable.error.js';
-export * from './http-errors/not-found.error.js';
-export * from './http-errors/unauthorized.error.js';
-export * from './http-errors/unprocessable-entity.error.js';
-export * from './resource-errors/resource-conflict.error.js';
-export * from './resource-errors/resource-not-found.error.js';

package/esm/exception/resource-errors/resource-conflict.error.d.ts

@@ -1,4 +0,0 @@
-import { ApiException } from '../api-exception.js';
-export declare class ResourceConflictError extends ApiException {
-    constructor(resource: string, fields: string | string[], cause?: Error);
-}

package/esm/exception/resource-errors/resource-conflict.error.js

@@ -1,15 +0,0 @@
-import { translate } from '@opra/i18n';
-import { HttpStatus } from '../../enums/index.js';
-import { ApiException } from '../api-exception.js';
-export class ResourceConflictError extends ApiException {
-    constructor(resource, fields, cause) {
-        super({
-            message: translate(`error:RESOURCE_CONFLICT`, { resource, fields }),
-            severity: 'error',
-            code: 'RESOURCE_CONFLICT',
-            subject: resource,
-            location: fields
-        }, cause);
-        this.status = HttpStatus.CONFLICT;
-    }
-}

package/esm/exception/resource-errors/resource-not-found.error.d.ts

@@ -1,4 +0,0 @@
-import { ApiException } from '../api-exception.js';
-export declare class ResourceNotFoundError extends ApiException {
-    constructor(resource: string, keyValue: any, cause?: Error);
-}

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

@@ -1,15 +0,0 @@
-import { translate } from '@opra/i18n';
-import { HttpStatus } from '../../enums/index.js';
-import { ApiException } from '../api-exception.js';
-export class ResourceNotFoundError extends ApiException {
-    constructor(resource, keyValue, cause) {
-        super({
-            message: translate(`error:RESOURCE_NOT_FOUND`, { resource: resource + '@' + keyValue }),
-            severity: 'error',
-            code: 'RESOURCE_NOT_FOUND',
-            subject: resource,
-            key: keyValue
-        }, cause);
-        this.status = HttpStatus.NOT_FOUND;
-    }
-}

package/esm/exception/wrap-error.d.ts

@@ -1,2 +0,0 @@
-import { ApiException, ErrorResponse } from './api-exception.js';
-export declare function wrapError(response: string | ErrorResponse | Error): ApiException;

package/esm/exception/wrap-error.js

@@ -1,13 +0,0 @@
-import { ApiException } from './api-exception.js';
-import { InternalServerError } from './http-errors/internal-server.error.js';
-export function wrapError(response) {
-    if (response instanceof ApiException)
-        return response;
-    if (response instanceof Error) {
-        const x = response;
-        if (typeof x.status === 'number' || typeof x.getStatus === 'function')
-            return new ApiException(response);
-        return new InternalServerError(response);
-    }
-    return new InternalServerError();
-}

package/esm/interfaces/query.interface.d.ts

@@ -1,115 +0,0 @@
-import { StrictOmit } from 'ts-gems';
-import { EntityResource, OpraSchema } from '@opra/schema';
-import { Expression } from '@opra/url';
-import { KeyValue, QueryType } from '../types.js';
-export declare type OpraQuery = OpraGetSchemaQuery | OpraCreateQuery | OpraGetEntityQuery | OpraSearchQuery | OpraUpdateQuery | OpraUpdateManyQuery | OpraDeleteQuery | OpraDeleteManyQuery;
-interface BaseOpraQuery {
-    queryType: QueryType;
-    scope: OpraSchema.QueryScope;
-    operation: OpraSchema.OperationType;
-}
-export interface OpraGetSchemaQuery extends BaseOpraQuery {
-    queryType: 'schema';
-    scope: OpraSchema.QueryScope;
-    operation: 'read';
-    resourcePath: string[];
-}
-export interface OpraCreateQuery extends BaseOpraQuery {
-    queryType: 'create';
-    scope: 'collection';
-    operation: 'create';
-    resource: EntityResource;
-    data: {};
-    pick?: string[];
-    omit?: string[];
-    include?: string[];
-}
-export interface OpraGetEntityQuery extends BaseOpraQuery {
-    queryType: 'get';
-    scope: 'instance';
-    operation: 'read';
-    resource: EntityResource;
-    keyValue: KeyValue;
-    pick?: string[];
-    omit?: string[];
-    include?: string[];
-    nested?: OpraPropertyQuery;
-}
-export interface OpraPropertyQuery extends BaseOpraQuery {
-    queryType: 'get';
-    scope: 'property';
-    operation: 'read';
-    property: OpraSchema.Field;
-    nested?: OpraPropertyQuery;
-}
-export interface OpraUpdateQuery extends BaseOpraQuery {
-    queryType: 'update';
-    scope: 'instance';
-    operation: 'update';
-    resource: EntityResource;
-    keyValue: KeyValue;
-    data: {};
-    pick?: string[];
-    omit?: string[];
-    include?: string[];
-}
-export interface OpraUpdateManyQuery extends BaseOpraQuery {
-    queryType: 'updateMany';
-    scope: 'collection';
-    operation: 'update';
-    resource: EntityResource;
-    filter?: string | Expression;
-    data: {};
-}
-export interface OpraDeleteQuery extends BaseOpraQuery {
-    queryType: 'delete';
-    scope: 'instance';
-    operation: 'delete';
-    resource: EntityResource;
-    keyValue: KeyValue;
-}
-export interface OpraDeleteManyQuery extends BaseOpraQuery {
-    queryType: 'deleteMany';
-    scope: 'collection';
-    operation: 'delete';
-    resource: EntityResource;
-    filter?: string | Expression;
-}
-export interface OpraSearchQuery extends BaseOpraQuery {
-    queryType: 'search';
-    scope: 'collection';
-    operation: 'read';
-    resource: EntityResource;
-    pick?: string[];
-    omit?: string[];
-    include?: string[];
-    filter?: string | Expression;
-    limit?: number;
-    skip?: number;
-    distinct?: boolean;
-    count?: boolean;
-    sort?: string[];
-}
-export declare type CreateQueryOptions = StrictOmit<OpraCreateQuery, 'queryType' | 'scope' | 'operation' | 'resource' | 'data'>;
-export declare type GetEntityQueryOptions = StrictOmit<OpraGetEntityQuery, 'queryType' | 'scope' | 'operation' | 'resource' | 'keyValue'>;
-export declare type SearchQueryOptions = StrictOmit<OpraSearchQuery, 'queryType' | 'scope' | 'operation' | 'resource'>;
-export declare type UpdateQueryOptions = StrictOmit<OpraUpdateQuery, 'queryType' | 'scope' | 'operation' | 'resource' | 'keyValue' | 'data'>;
-export declare type UpdateManyQueryOptions = StrictOmit<OpraUpdateManyQuery, 'queryType' | 'scope' | 'operation' | 'resource' | 'data'>;
-export declare type DeleteQueryOptions = StrictOmit<OpraDeleteQuery, 'queryType' | 'scope' | 'operation' | 'resource' | 'keyValue'>;
-export declare type DeleteManyQueryOption = StrictOmit<OpraDeleteManyQuery, 'queryType' | 'scope' | 'operation' | 'resource'>;
-export declare namespace OpraQuery {
-    function forCreate(resource: EntityResource, values: {}, options?: CreateQueryOptions): OpraCreateQuery;
-    function forGetSchema(resourcePath: string[], options?: GetEntityQueryOptions): OpraGetSchemaQuery;
-    function forGetEntity(resource: EntityResource, key: KeyValue, options?: GetEntityQueryOptions): OpraGetEntityQuery;
-    function forSearch(resource: EntityResource, options?: SearchQueryOptions): OpraSearchQuery;
-    function forGetProperty(property: OpraSchema.Field, options?: StrictOmit<OpraPropertyQuery, 'queryType' | 'scope' | 'operation' | 'property'>): OpraPropertyQuery;
-    function forUpdate(resource: EntityResource, keyValue: KeyValue, values: any, options?: UpdateQueryOptions): OpraUpdateQuery;
-    function forUpdateMany(resource: EntityResource, values: any, options?: UpdateManyQueryOptions): OpraUpdateManyQuery;
-    function forDelete(resource: EntityResource, key: KeyValue): OpraDeleteQuery;
-    function forDeleteMany(resource: EntityResource, options?: DeleteManyQueryOption): OpraDeleteManyQuery;
-    function isCreateQuery(q: any): q is OpraCreateQuery;
-    function isSearchQuery(q: any): q is OpraSearchQuery;
-    function isReadQuery(q: any): q is OpraGetEntityQuery;
-    function isDeleteQuery(q: any): q is OpraDeleteQuery;
-}
-export {};

package/esm/interfaces/query.interface.js

@@ -1,203 +0,0 @@
-import _ from 'lodash';
-import { ComplexType } from '@opra/schema';
-import { pathToTree } from '../utils/path-to-tree.js';
-export var OpraQuery;
-(function (OpraQuery) {
-    function forCreate(resource, values, options) {
-        if (options?.pick)
-            options.pick = normalizePick(resource, options.pick);
-        if (options?.omit)
-            options.omit = normalizePick(resource, options.omit);
-        if (options?.include)
-            options.include = normalizePick(resource, options.include);
-        const out = {
-            queryType: 'create',
-            scope: 'collection',
-            operation: 'create',
-            resource,
-            data: values
-        };
-        Object.assign(out, _.omit(options, Object.keys(out)));
-        return out;
-    }
-    OpraQuery.forCreate = forCreate;
-    function forGetSchema(resourcePath, options) {
-        // if (options?.pick)
-        //   options.pick = normalizePick(resource, options.pick);
-        // if (options?.omit)
-        //   options.omit = normalizePick(resource, options.omit);
-        // if (options?.include)
-        //   options.include = normalizePick(resource, options.include);
-        const out = {
-            queryType: 'schema',
-            scope: 'instance',
-            resourcePath,
-            operation: 'read',
-        };
-        Object.assign(out, _.omit(options, Object.keys(out)));
-        return out;
-    }
-    OpraQuery.forGetSchema = forGetSchema;
-    function forGetEntity(resource, key, options) {
-        if (options?.pick)
-            options.pick = normalizePick(resource, options.pick);
-        if (options?.omit)
-            options.omit = normalizePick(resource, options.omit);
-        if (options?.include)
-            options.include = normalizePick(resource, options.include);
-        checkKeyFields(resource, key);
-        const out = {
-            queryType: 'get',
-            scope: 'instance',
-            operation: 'read',
-            resource,
-            keyValue: key
-        };
-        Object.assign(out, _.omit(options, Object.keys(out)));
-        return out;
-    }
-    OpraQuery.forGetEntity = forGetEntity;
-    function forSearch(resource, options) {
-        if (options?.pick)
-            options.pick = normalizePick(resource, options.pick);
-        if (options?.omit)
-            options.omit = normalizePick(resource, options.omit);
-        if (options?.include)
-            options.include = normalizePick(resource, options.include);
-        if (options?.sort)
-            options.sort = normalizePick(resource, options.sort); // todo check allowed sort fields
-        const out = {
-            queryType: 'search',
-            scope: 'collection',
-            operation: 'read',
-            resource
-        };
-        Object.assign(out, _.omit(options, Object.keys(out)));
-        return out;
-    }
-    OpraQuery.forSearch = forSearch;
-    function forGetProperty(property, options) {
-        const out = {
-            queryType: 'get',
-            scope: 'property',
-            operation: 'read',
-            property
-        };
-        Object.assign(out, _.omit(options, Object.keys(out)));
-        return out;
-    }
-    OpraQuery.forGetProperty = forGetProperty;
-    function forUpdate(resource, keyValue, values, options) {
-        if (options?.pick)
-            options.pick = normalizePick(resource, options.pick);
-        if (options?.omit)
-            options.omit = normalizePick(resource, options.omit);
-        if (options?.include)
-            options.include = normalizePick(resource, options.include);
-        checkKeyFields(resource, keyValue);
-        const out = {
-            queryType: 'update',
-            scope: 'instance',
-            operation: 'update',
-            resource,
-            keyValue,
-            data: values
-        };
-        Object.assign(out, _.omit(options, Object.keys(out)));
-        return out;
-    }
-    OpraQuery.forUpdate = forUpdate;
-    function forUpdateMany(resource, values, options) {
-        const out = {
-            queryType: 'updateMany',
-            scope: 'collection',
-            operation: 'update',
-            resource,
-            data: values
-        };
-        Object.assign(out, _.omit(options, Object.keys(out)));
-        return out;
-    }
-    OpraQuery.forUpdateMany = forUpdateMany;
-    function forDelete(resource, key) {
-        checkKeyFields(resource, key);
-        return {
-            queryType: 'delete',
-            scope: 'instance',
-            operation: 'delete',
-            resource,
-            keyValue: key
-        };
-    }
-    OpraQuery.forDelete = forDelete;
-    function forDeleteMany(resource, options) {
-        const out = {
-            queryType: 'deleteMany',
-            scope: 'collection',
-            operation: 'delete',
-            resource,
-        };
-        Object.assign(out, _.omit(options, Object.keys(out)));
-        return out;
-    }
-    OpraQuery.forDeleteMany = forDeleteMany;
-    function isCreateQuery(q) {
-        return q && typeof q === 'object' && q.scope === 'collection' && q.queryType === 'create';
-    }
-    OpraQuery.isCreateQuery = isCreateQuery;
-    function isSearchQuery(q) {
-        return q && typeof q === 'object' && q.scope === 'collection' && q.queryType === 'search';
-    }
-    OpraQuery.isSearchQuery = isSearchQuery;
-    function isReadQuery(q) {
-        return q && typeof q === 'object' && q.scope === 'instance' && q.queryType === 'read';
-    }
-    OpraQuery.isReadQuery = isReadQuery;
-    function isDeleteQuery(q) {
-        return q && typeof q === 'object' && q.scope === 'instance' && q.queryType === 'delete';
-    }
-    OpraQuery.isDeleteQuery = isDeleteQuery;
-})(OpraQuery || (OpraQuery = {}));
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-function checkKeyFields(resource, key) {
-    if (!resource.dataType.primaryKey)
-        throw new Error(`"${resource.name}" has no primary key`);
-}
-function normalizePick(resource, fields) {
-    const fieldsTree = pathToTree(fields) || {};
-    return _normalizeFieldsList([], resource.service, resource, resource.dataType, fieldsTree, '', {
-        additionalFields: true
-    });
-}
-function _normalizeFieldsList(target, service, resource, dataType, node, parentPath = '', options) {
-    let curPath = '';
-    for (const k of Object.keys(node)) {
-        const nodeVal = node[k];
-        const prop = dataType?.fields.get(k);
-        if (!prop) {
-            curPath = parentPath ? parentPath + '.' + k : k;
-            if (!options?.additionalFields || (dataType && !dataType.additionalFields))
-                throw new TypeError(`Unknown field path "${resource.name + '.' + curPath}"`);
-            if (typeof nodeVal === 'object')
-                _normalizeFieldsList(target, service, resource, undefined, nodeVal, curPath, options);
-            else
-                target.push(curPath);
-            continue;
-        }
-        curPath = parentPath ? parentPath + '.' + prop.name : prop.name;
-        const propType = service.getDataType(prop.type || 'string');
-        if (typeof nodeVal === 'object') {
-            if (!(propType && propType instanceof ComplexType))
-                throw new TypeError(`"${curPath}" is not a complex type and has no sub fields`);
-            if (target.findIndex(x => x === parentPath) >= 0)
-                continue;
-            target = _normalizeFieldsList(target, service, resource, propType, nodeVal, curPath, options);
-            continue;
-        }
-        if (target.findIndex(x => x.startsWith(curPath + '.')) >= 0) {
-            target = target.filter(x => !x.startsWith(curPath + '.'));
-        }
-        target.push(curPath);
-    }
-    return target;
-}

package/esm/services/json-data-service.d.ts

@@ -1,68 +0,0 @@
-import { Maybe } from 'ts-gems';
-import { Expression } from '@opra/url';
-import { QueryContext } from '../implementation/query-context.js';
-import { IEntityService } from '../interfaces/entity-service.interface.js';
-import { OpraQuery } from '../interfaces/query.interface.js';
-import { EntityInput, EntityOutput, QueryType } from '../types.js';
-export interface JsonDataServiceAgs<T> {
-    resourceName: string;
-    data: T[];
-    primaryKey: string;
-}
-export declare namespace JsonDataService {
-    type GetOptions = {
-        pick?: string[];
-        omit?: string[];
-        include?: string[];
-    };
-    type SearchOptions = {
-        pick?: string[];
-        omit?: string[];
-        include?: string[];
-        limit?: number;
-        skip?: number;
-        distinct?: boolean;
-        total?: boolean;
-        filter?: string | Expression | {};
-    };
-    type CreateOptions = {
-        pick?: string[];
-        omit?: string[];
-        include?: string[];
-    };
-    type UpdateOptions = {
-        pick?: string[];
-        omit?: string[];
-        include?: string[];
-    };
-    type UpdateManyOptions = {
-        filter?: string | Expression | {};
-    };
-    type DeleteManyOptions = {
-        filter?: string | Expression | {};
-    };
-}
-export declare class JsonDataService<T, TOutput = EntityOutput<T>> implements IEntityService {
-    resourceName: string;
-    data: T[];
-    primaryKey: string;
-    constructor(args: JsonDataServiceAgs<T>);
-    processRequest(ctx: QueryContext): any;
-    get(keyValue: any, options?: JsonDataService.GetOptions): Maybe<TOutput>;
-    count(options?: JsonDataService.SearchOptions): Maybe<number>;
-    search(options?: JsonDataService.SearchOptions): Maybe<TOutput>[];
-    create(data: EntityInput<T>, options?: JsonDataService.CreateOptions): TOutput;
-    update(keyValue: any, data: EntityInput<T>, options?: JsonDataService.UpdateOptions): Maybe<TOutput>;
-    updateMany(data: EntityInput<T>, options?: JsonDataService.UpdateManyOptions): number;
-    delete(keyValue: any): boolean;
-    deleteMany(options?: JsonDataService.DeleteManyOptions): number;
-    static filterFields(obj: any, pick: string[] | undefined, omit: string[] | undefined, include: string[] | undefined): any;
-    static prepare(query: OpraQuery): {
-        method: QueryType;
-        options: any;
-        keyValue?: any;
-        values?: any;
-        args: any[];
-    };
-    static convertFilter(str: string | Expression | undefined | {}): any;
-}