@opra/core 0.8.0 → 0.12.0

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

@@ -1,83 +0,0 @@
-import { Maybe } from 'ts-gems';
-import { CollectionResourceInfo, ComplexType, Expression, OpraQuery, OpraSchema } from '@opra/common';
-import { SingleRequestContext } from '../adapter/request-contexts/single-request-context.js';
-import { PartialInput, PartialOutput } from '../types.js';
-export interface JsonCollectionServiceOptions {
-    resourceName?: string;
-    defaultLimit?: number;
-    data?: any[];
-}
-export declare class JsonCollectionService<T, TOutput = PartialOutput<T>> {
-    readonly resource: CollectionResourceInfo;
-    private _status;
-    private _initError;
-    private _dbName;
-    private _initData?;
-    defaultLimit: number;
-    constructor(resource: CollectionResourceInfo, options?: JsonCollectionServiceOptions);
-    get dataType(): ComplexType;
-    get primaryKey(): string;
-    get resourceName(): string;
-    close(): Promise<void>;
-    processRequest(ctx: SingleRequestContext): Promise<any>;
-    get(keyValue: any, options?: JsonCollectionService.GetOptions): Promise<Maybe<TOutput>>;
-    count(options?: JsonCollectionService.SearchOptions): Promise<number>;
-    search(options?: JsonCollectionService.SearchOptions): Promise<TOutput[]>;
-    create(data: PartialInput<T>, options?: JsonCollectionService.CreateOptions): Promise<TOutput>;
-    update(keyValue: any, data: PartialInput<T>, options?: JsonCollectionService.UpdateOptions): Promise<Maybe<TOutput>>;
-    updateMany(data: PartialInput<T>, options?: JsonCollectionService.UpdateManyOptions): Promise<number>;
-    delete(keyValue: any): Promise<boolean>;
-    deleteMany(options?: JsonCollectionService.DeleteManyOptions): Promise<number>;
-    private _waitInitializing;
-    protected _init(): Promise<void>;
-    protected _prepare(query: OpraQuery): {
-        method: OpraSchema.CollectionMethod;
-        options: any;
-        keyValue?: any;
-        values?: any;
-        args: any[];
-    };
-    protected _convertSelect(args: {
-        pick?: string[];
-        omit?: string[];
-        include?: string[];
-    }): string[];
-    protected _convertFilter(str: string | Expression | undefined | {}): any;
-}
-export declare namespace JsonCollectionService {
-    type CountOptions = {
-        filter?: string | Expression | {};
-    };
-    type CreateOptions = {
-        pick?: string[];
-        omit?: string[];
-        include?: string[];
-    };
-    type GetOptions = {
-        pick?: string[];
-        omit?: string[];
-        include?: string[];
-    };
-    type SearchOptions = {
-        pick?: string[];
-        omit?: string[];
-        include?: string[];
-        filter?: any[];
-        sort?: string[];
-        limit?: number;
-        skip?: number;
-        distinct?: boolean;
-        count?: boolean;
-    };
-    type UpdateOptions = {
-        pick?: string[];
-        omit?: string[];
-        include?: string[];
-    };
-    type UpdateManyOptions = {
-        filter?: any[];
-    };
-    type DeleteManyOptions = {
-        filter?: any[];
-    };
-}

package/esm/services/json-collection-service.js

@@ -1,492 +0,0 @@
-import { isNil, omitBy } from 'lodash';
-import merge from 'putil-merge';
-import { nSQL } from "@nano-sql/core";
-import { ArrayExpression, BadRequestError, BooleanLiteral, CollectionResourceInfo, ComparisonExpression, ComplexType, DateLiteral, Expression, LogicalExpression, MethodNotAllowedError, NullLiteral, NumberLiteral, ParenthesesExpression, parseFilter, pathToTree, QualifiedIdentifier, ResourceConflictError, StringLiteral, TimeLiteral } from '@opra/common';
-let dbId = 1;
-const indexingTypes = ['int', 'float', 'number', 'date', 'string'];
-export class JsonCollectionService {
-    constructor(resource, options) {
-        this.resource = resource;
-        this._status = '';
-        if (this.resource.keyFields.length > 1)
-            throw new TypeError('JsonDataService currently doesn\'t support multiple primary keys');
-        this.defaultLimit = options?.defaultLimit ?? 10;
-        this._initData = options?.data;
-    }
-    get dataType() {
-        return this.resource.dataType;
-    }
-    get primaryKey() {
-        return this.resource.keyFields[0];
-    }
-    get resourceName() {
-        return this.resource.name;
-    }
-    async close() {
-        await this._waitInitializing();
-        if (this._status === 'initialized') {
-            this._status = 'initializing';
-            try {
-                await nSQL().disconnect(this._dbName);
-            }
-            finally {
-                this._status = '';
-            }
-        }
-    }
-    async processRequest(ctx) {
-        const prepared = this._prepare(ctx.query);
-        const fn = this[prepared.method];
-        if (!fn)
-            throw new TypeError(`Unimplemented method (${prepared.method})`);
-        // @ts-ignore
-        return fn.apply(this, prepared.args);
-    }
-    async get(keyValue, options) {
-        await this._init();
-        const select = this._convertSelect({
-            pick: options?.pick,
-            omit: options?.omit,
-            include: options?.include,
-        });
-        nSQL().useDatabase(this._dbName);
-        try {
-            const rows = await nSQL(this.resourceName)
-                .query('select', select)
-                .where([this.primaryKey, '=', keyValue])
-                .exec();
-            return unFlatten(rows[0]);
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    async count(options) {
-        await this._init();
-        nSQL().useDatabase(this._dbName);
-        const rows = await nSQL(this.resourceName)
-            .query('select', ['COUNT(*) as count'])
-            .where(options?.filter || [])
-            .exec();
-        return (rows[0]?.count) || 0;
-    }
-    async search(options) {
-        await this._init();
-        const select = this._convertSelect({
-            pick: options?.pick,
-            omit: options?.omit,
-            include: options?.include,
-        });
-        const filter = this._convertFilter(options?.filter);
-        nSQL().useDatabase(this._dbName);
-        const query = nSQL(this.resourceName)
-            .query('select', select)
-            .limit(options?.limit || 10)
-            .offset(options?.skip || 0)
-            .orderBy(options?.sort || [])
-            .where(filter || []);
-        return (await query.exec()).map(x => unFlatten(x));
-    }
-    async create(data, options) {
-        if (!data[this.primaryKey])
-            throw new BadRequestError({
-                message: 'You must provide primary key value'
-            });
-        await this._init();
-        const keyValue = data[this.primaryKey];
-        nSQL().useDatabase(this._dbName);
-        const rows = await nSQL(this.resourceName).query('select', [this.primaryKey])
-            .where([this.primaryKey, '=', keyValue])
-            .exec();
-        if (rows.length)
-            throw new ResourceConflictError(this.resourceName, this.primaryKey);
-        await nSQL(this.resourceName).query('upsert', data)
-            .exec();
-        return await this.get(keyValue, options);
-    }
-    async update(keyValue, data, options) {
-        await this._init();
-        nSQL().useDatabase(this._dbName);
-        await nSQL(this.resourceName)
-            .query('conform rows', (row) => {
-            const out = merge({}, row, { deep: true, clone: true });
-            merge(out, data, { deep: true });
-            return out;
-        })
-            .where([this.primaryKey, '=', keyValue])
-            .exec();
-        // await nSQL(this.resourceName).query("rebuild indexes").exec();
-        return this.get(keyValue, options);
-    }
-    async updateMany(data, options) {
-        await this._init();
-        const filter = this._convertFilter(options?.filter);
-        nSQL().useDatabase(this._dbName);
-        let affected = 0;
-        await nSQL(this.resourceName)
-            .query('conform rows', (row) => {
-            const out = merge({}, row, { deep: true, clone: true });
-            merge(out, data, { deep: true });
-            affected++;
-            return out;
-        })
-            .where(filter)
-            .exec();
-        // await nSQL(this.resourceName).query("rebuild indexes").exec();
-        return affected;
-    }
-    async delete(keyValue) {
-        await this._init();
-        nSQL().useDatabase(this._dbName);
-        const result = await nSQL(this.resourceName)
-            .query('delete')
-            .where([this.primaryKey, '=', keyValue])
-            .exec();
-        return !!result.length;
-    }
-    async deleteMany(options) {
-        await this._init();
-        const filter = this._convertFilter(options?.filter);
-        nSQL().useDatabase(this._dbName);
-        const result = await nSQL(this.resourceName)
-            .query('delete')
-            .where(filter)
-            .exec();
-        return result.length;
-    }
-    async _waitInitializing() {
-        if (this._status === 'initializing') {
-            return new Promise((resolve, reject) => {
-                const reTry = () => setTimeout(() => {
-                    if (this._status === '')
-                        return resolve(this._init());
-                    if (this._status === 'error')
-                        return reject(this._initError);
-                    if (this._status === 'initialized')
-                        return resolve();
-                    reTry();
-                }, 50).unref();
-                reTry();
-            });
-        }
-    }
-    async _init() {
-        await this._waitInitializing();
-        if (this._status === 'initialized')
-            return;
-        this._status = 'initializing';
-        this._dbName = 'JsonDataService_DB_' + (dbId++);
-        try {
-            const table = {
-                name: this.resourceName,
-                model: {},
-                indexes: {}
-            };
-            for (const [k, f] of this.resource.dataType.fields.entries()) {
-                const fieldType = this.resource.document.getDataType(f.type || 'string');
-                const o = table.model[k + ':' + dataTypeToSQLType(fieldType, !!f.isArray)] = {};
-                if (k === this.primaryKey)
-                    o.pk = true;
-            }
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const indexes = table.indexes;
-            // Add indexes for sort fields
-            const searchResolver = this.resource.metadata.search;
-            if (searchResolver) {
-                if (searchResolver.sortFields) {
-                    searchResolver.sortFields.forEach(fieldName => {
-                        const f = this.dataType.getField(fieldName);
-                        const fieldType = this.resource.document.getDataType(f.type || 'string');
-                        const t = dataTypeToSQLType(fieldType, !!f.isArray);
-                        if (indexingTypes.includes(t))
-                            indexes[fieldName + ':' + t] = {};
-                    });
-                }
-                if (searchResolver.filters) {
-                    searchResolver.filters.forEach(filter => {
-                        const f = this.dataType.getField(filter.field);
-                        const fieldType = this.resource.document.getDataType(f.type || 'string');
-                        const t = dataTypeToSQLType(fieldType, !!f.isArray);
-                        if (indexingTypes.includes(t))
-                            indexes[filter.field + ':' + t] = {};
-                    });
-                }
-            }
-            await nSQL().createDatabase({
-                id: this._dbName,
-                version: 3,
-                tables: [table]
-            });
-            this._status = 'initialized';
-            if (this._initData) {
-                nSQL().useDatabase(this._dbName);
-                await nSQL(this.resourceName)
-                    .query('upsert', this._initData)
-                    .exec();
-                delete this._initData;
-            }
-        }
-        catch (e) {
-            this._initError = e;
-            this._status = 'error';
-            throw e;
-        }
-    }
-    _prepare(query) {
-        if (query.resource instanceof CollectionResourceInfo) {
-            if (query.dataType !== this.dataType)
-                throw new TypeError(`Query data type (${query.dataType.name}) ` +
-                    `differs from JsonCollectionService data type (${this.dataType.name})`);
-        }
-        switch (query.method) {
-            case 'count': {
-                const options = omitBy({
-                    filter: this._convertFilter(query.filter)
-                }, isNil);
-                return {
-                    method: query.method,
-                    options,
-                    args: [options]
-                };
-            }
-            case 'create': {
-                const options = omitBy({
-                    pick: query.pick,
-                    omit: query.omit,
-                    include: query.include
-                }, isNil);
-                const { data } = query;
-                return {
-                    method: query.method,
-                    values: data,
-                    options,
-                    args: [data, options]
-                };
-            }
-            case 'get': {
-                if (query.kind === 'CollectionGetQuery') {
-                    const options = omitBy({
-                        pick: query.pick,
-                        omit: query.omit,
-                        include: query.include
-                    }, isNil);
-                    const keyValue = query.keyValue;
-                    return {
-                        method: query.method,
-                        keyValue,
-                        options,
-                        args: [keyValue, options]
-                    };
-                }
-                if (query.kind === 'FieldGetQuery') {
-                    // todo
-                }
-                break;
-            }
-            case 'search': {
-                if (query.distinct)
-                    throw new MethodNotAllowedError({
-                        message: '$distinct parameter is not supported by JsonDataService'
-                    });
-                const options = omitBy({
-                    pick: query.pick,
-                    omit: query.omit,
-                    include: query.include,
-                    filter: this._convertFilter(query.filter),
-                    sort: query.sort?.length ? query.sort : undefined,
-                    skip: query.skip,
-                    limit: query.limit,
-                    offset: query.skip,
-                    count: query.count,
-                }, isNil);
-                return {
-                    method: query.method,
-                    options,
-                    args: [options]
-                };
-            }
-            case 'update': {
-                const options = omitBy({
-                    pick: query.pick,
-                    omit: query.omit,
-                    include: query.include
-                }, isNil);
-                const { data } = query;
-                const keyValue = query.keyValue;
-                return {
-                    method: query.method,
-                    keyValue: query.keyValue,
-                    values: data,
-                    options,
-                    args: [keyValue, data, options]
-                };
-            }
-            case 'updateMany': {
-                const options = omitBy({
-                    filter: this._convertFilter(query.filter)
-                }, isNil);
-                const { data } = query;
-                return {
-                    method: query.method,
-                    options,
-                    args: [data, options]
-                };
-            }
-            case 'delete': {
-                const options = {};
-                const keyValue = query.keyValue;
-                return {
-                    method: query.method,
-                    keyValue,
-                    options,
-                    args: [keyValue, options]
-                };
-            }
-            case 'deleteMany': {
-                const options = omitBy({
-                    filter: this._convertFilter(query.filter)
-                }, isNil);
-                return {
-                    method: query.method,
-                    options,
-                    args: [options]
-                };
-            }
-        }
-        throw new Error(`Unimplemented query type "${query.method}"`);
-    }
-    _convertSelect(args) {
-        const result = [];
-        const document = this.dataType.document;
-        const processDataType = (dt, path, pick, omit, include) => {
-            let kl;
-            for (const [k, f] of dt.fields) {
-                kl = k.toLowerCase();
-                if (omit?.[kl] === true)
-                    continue;
-                if ((((!pick && !f.exclusive) || pick?.[kl])) || include?.[kl]) {
-                    const fieldType = document.getDataType(f.type);
-                    const subPath = (path ? path + '.' : '') + f.name;
-                    if (fieldType instanceof ComplexType) {
-                        processDataType(fieldType, subPath, typeof pick?.[kl] === 'object' ? pick?.[kl] : undefined, typeof omit?.[kl] === 'object' ? omit?.[kl] : undefined, typeof include?.[kl] === 'object' ? include?.[kl] : undefined);
-                        continue;
-                    }
-                    result.push(subPath);
-                }
-            }
-        };
-        processDataType(this.dataType, '', (args.pick ? pathToTree(args.pick, true) : undefined), (args.omit ? pathToTree(args.omit, true) : undefined), (args.include ? pathToTree(args.include, true) : undefined));
-        return result;
-    }
-    _convertFilter(str) {
-        const ast = typeof str === 'string'
-            ? parseFilter(str)
-            : str;
-        if (!ast || !(ast instanceof Expression))
-            return ast;
-        if (ast instanceof ComparisonExpression) {
-            const left = this._convertFilter(ast.left);
-            const right = this._convertFilter(ast.right);
-            switch (ast.op) {
-                case '=':
-                    return [left, '=', right];
-                case '!=':
-                    return [left, '!=', right];
-                case '>':
-                    return [left, '>', right];
-                case '>=':
-                    return [left, '>=', right];
-                case '<':
-                    return [left, '<', right];
-                case '<=':
-                    return [left, '<=', right];
-                case 'like':
-                    return [left, 'LIKE', right];
-                case '!like':
-                    return [left, 'NOT LIKE', right];
-                case 'in':
-                    return [left, 'IN', Array.isArray(right) ? right : [right]];
-                case '!in':
-                    return [left, 'NOT IN', Array.isArray(right) ? right : [right]];
-                default:
-                    throw new Error(`ComparisonExpression operator (${ast.op}) not implemented yet`);
-            }
-        }
-        if (ast instanceof QualifiedIdentifier) {
-            return ast.value;
-        }
-        if (ast instanceof NumberLiteral ||
-            ast instanceof StringLiteral ||
-            ast instanceof BooleanLiteral ||
-            ast instanceof NullLiteral ||
-            ast instanceof DateLiteral ||
-            ast instanceof TimeLiteral) {
-            return ast.value;
-        }
-        if (ast instanceof ArrayExpression) {
-            return ast.items.map(item => this._convertFilter(item));
-        }
-        if (ast instanceof LogicalExpression) {
-            return ast.items.map(item => this._convertFilter(item))
-                .reduce((a, v) => {
-                if (a.length)
-                    a.push(ast.op.toUpperCase());
-                a.push(v);
-                return a;
-            }, []);
-        }
-        if (ast instanceof ArrayExpression) {
-            return ast.items.map(item => this._convertFilter(item));
-        }
-        if (ast instanceof ParenthesesExpression) {
-            return this._convertFilter(ast.expression);
-        }
-        throw new Error(`${ast.kind} is not implemented yet`);
-    }
-}
-function unFlatten(input) {
-    if (!input)
-        return;
-    const target = {};
-    for (const k of Object.keys(input)) {
-        if (k.includes('.')) {
-            const keys = k.split('.');
-            let o = target;
-            for (let i = 0; i < keys.length - 1; i++) {
-                o = o[keys[i]] = o[keys[i]] || {};
-            }
-            o[keys[keys.length - 1]] = input[k];
-        }
-        else
-            target[k] = input[k];
-    }
-    return target;
-}
-function dataTypeToSQLType(dataType, isArray) {
-    let out = 'any';
-    if (dataType.kind !== 'SimpleType')
-        out = 'object';
-    else {
-        switch (dataType.name) {
-            case 'boolean':
-            case 'number':
-            case 'string':
-                out = dataType.name;
-                break;
-            case 'integer':
-                out = 'int';
-                break;
-            // case 'date': //there is bug in nano-sql.
-            // case 'date-time':
-            //   out = 'date';
-            //   break;
-            case 'time':
-                out = 'string';
-                break;
-            case 'uuid':
-                out = 'uuid';
-                break;
-        }
-    }
-    return out + (isArray ? '[]' : '');
-}