@cloudbase/database 1.4.1-alpha.0 → 1.4.2

package/dist/esm/serializer/query.js

@@ -1,251 +0,0 @@
-import { isQueryCommand, isComparisonCommand, QUERY_COMMANDS_LITERAL } from '../commands/query';
-import { isLogicCommand, LOGIC_COMMANDS_LITERAL } from '../commands/logic';
-import { SYMBOL_UNSET_FIELD_NAME, SYMBOL_GEO_POINT } from '../helper/symbol';
-import { getType, isObject, isArray, isRegExp, isDate } from '../utils/type';
-import { operatorToString } from '../operator-map';
-import { flattenQueryObject, isConversionRequired, encodeInternalDataType } from './common';
-import { stringifyByEJSON } from '../utils/utils';
-import { Validate } from '../validate';
-export class QuerySerializer {
-    constructor() { }
-    static encode(query) {
-        const encoder = new QueryEncoder();
-        return encoder.encodeQuery(query);
-    }
-    static encodeEJSON(query, raw) {
-        const encoder = new QueryEncoder();
-        return stringifyByEJSON(raw ? query : encoder.encodeQuery(query));
-    }
-}
-class QueryEncoder {
-    encodeQuery(query, key) {
-        if (isConversionRequired(query)) {
-            if (isLogicCommand(query)) {
-                return this.encodeLogicCommand(query);
-            }
-            else if (isQueryCommand(query)) {
-                return this.encodeQueryCommand(query);
-            }
-            else if (isRegExp(query)) {
-                return { [key]: this.encodeRegExp(query) };
-            }
-            else if (isDate(query)) {
-                return { [key]: query };
-            }
-            else {
-                return { [key]: this.encodeQueryObject(query) };
-            }
-        }
-        else {
-            if (isObject(query)) {
-                return this.encodeQueryObject(query);
-            }
-            else {
-                return query;
-            }
-        }
-    }
-    encodeRegExp(query) {
-        return {
-            $regularExpression: {
-                pattern: query.source,
-                options: query.flags
-            }
-        };
-    }
-    encodeLogicCommand(query) {
-        switch (query.operator) {
-            case LOGIC_COMMANDS_LITERAL.NOR:
-            case LOGIC_COMMANDS_LITERAL.AND:
-            case LOGIC_COMMANDS_LITERAL.OR: {
-                const $op = operatorToString(query.operator);
-                const subqueries = query.operands.map((oprand) => this.encodeQuery(oprand, query.fieldName));
-                return {
-                    [$op]: subqueries
-                };
-            }
-            case LOGIC_COMMANDS_LITERAL.NOT: {
-                const $op = operatorToString(query.operator);
-                const operatorExpression = query.operands[0];
-                if (isRegExp(operatorExpression)) {
-                    return {
-                        [query.fieldName]: {
-                            [$op]: this.encodeRegExp(operatorExpression)
-                        }
-                    };
-                }
-                else {
-                    const subqueries = this.encodeQuery(operatorExpression)[query.fieldName];
-                    return {
-                        [query.fieldName]: {
-                            [$op]: subqueries
-                        }
-                    };
-                }
-            }
-            default: {
-                const $op = operatorToString(query.operator);
-                if (query.operands.length === 1) {
-                    const subquery = this.encodeQuery(query.operands[0]);
-                    return {
-                        [$op]: subquery
-                    };
-                }
-                else {
-                    const subqueries = query.operands.map(this.encodeQuery.bind(this));
-                    return {
-                        [$op]: subqueries
-                    };
-                }
-            }
-        }
-    }
-    encodeQueryCommand(query) {
-        if (isComparisonCommand(query)) {
-            return this.encodeComparisonCommand(query);
-        }
-        else {
-            return this.encodeComparisonCommand(query);
-        }
-    }
-    encodeComparisonCommand(query) {
-        if (query.fieldName === SYMBOL_UNSET_FIELD_NAME) {
-            throw new Error('Cannot encode a comparison command with unset field name');
-        }
-        const $op = operatorToString(query.operator);
-        switch (query.operator) {
-            case QUERY_COMMANDS_LITERAL.EQ:
-            case QUERY_COMMANDS_LITERAL.NEQ:
-            case QUERY_COMMANDS_LITERAL.LT:
-            case QUERY_COMMANDS_LITERAL.LTE:
-            case QUERY_COMMANDS_LITERAL.GT:
-            case QUERY_COMMANDS_LITERAL.GTE:
-            case QUERY_COMMANDS_LITERAL.ELEM_MATCH:
-            case QUERY_COMMANDS_LITERAL.EXISTS:
-            case QUERY_COMMANDS_LITERAL.SIZE:
-            case QUERY_COMMANDS_LITERAL.MOD: {
-                return {
-                    [query.fieldName]: {
-                        [$op]: encodeInternalDataType(query.operands[0])
-                    }
-                };
-            }
-            case QUERY_COMMANDS_LITERAL.IN:
-            case QUERY_COMMANDS_LITERAL.NIN:
-            case QUERY_COMMANDS_LITERAL.ALL: {
-                return {
-                    [query.fieldName]: {
-                        [$op]: encodeInternalDataType(query.operands)
-                    }
-                };
-            }
-            case QUERY_COMMANDS_LITERAL.GEO_NEAR: {
-                const options = query.operands[0];
-                return {
-                    [query.fieldName]: {
-                        $nearSphere: {
-                            $geometry: options.geometry.toJSON(),
-                            $maxDistance: options.maxDistance,
-                            $minDistance: options.minDistance
-                        }
-                    }
-                };
-            }
-            case QUERY_COMMANDS_LITERAL.GEO_WITHIN: {
-                const options = query.operands[0];
-                if (options.centerSphere) {
-                    Validate.isCentersPhere(options.centerSphere);
-                    const centerSphere = options.centerSphere;
-                    if (centerSphere[0]._internalType === SYMBOL_GEO_POINT) {
-                        return {
-                            [query.fieldName]: {
-                                $geoWithin: {
-                                    $centerSphere: [centerSphere[0].toJSON().coordinates, centerSphere[1]]
-                                }
-                            }
-                        };
-                    }
-                    return {
-                        [query.fieldName]: {
-                            $geoWithin: {
-                                $centerSphere: options.centerSphere
-                            }
-                        }
-                    };
-                }
-                return {
-                    [query.fieldName]: {
-                        $geoWithin: {
-                            $geometry: options.geometry.toJSON()
-                        }
-                    }
-                };
-            }
-            case QUERY_COMMANDS_LITERAL.GEO_INTERSECTS: {
-                const options = query.operands[0];
-                return {
-                    [query.fieldName]: {
-                        $geoIntersects: {
-                            $geometry: options.geometry.toJSON()
-                        }
-                    }
-                };
-            }
-            default: {
-                return {
-                    [query.fieldName]: {
-                        [$op]: encodeInternalDataType(query.operands[0])
-                    }
-                };
-            }
-        }
-    }
-    encodeQueryObject(query) {
-        const flattened = flattenQueryObject(query);
-        for (const key in flattened) {
-            const val = flattened[key];
-            if (isLogicCommand(val)) {
-                flattened[key] = val._setFieldName(key);
-                const condition = this.encodeLogicCommand(flattened[key]);
-                this.mergeConditionAfterEncode(flattened, condition, key);
-            }
-            else if (isComparisonCommand(val)) {
-                flattened[key] = val._setFieldName(key);
-                const condition = this.encodeComparisonCommand(flattened[key]);
-                this.mergeConditionAfterEncode(flattened, condition, key);
-            }
-            else if (isConversionRequired(val)) {
-                flattened[key] = encodeInternalDataType(val);
-            }
-        }
-        return flattened;
-    }
-    mergeConditionAfterEncode(query, condition, key) {
-        if (!condition[key]) {
-            delete query[key];
-        }
-        for (const conditionKey in condition) {
-            if (query[conditionKey]) {
-                if (isArray(query[conditionKey])) {
-                    query[conditionKey] = query[conditionKey].concat(condition[conditionKey]);
-                }
-                else if (isObject(query[conditionKey])) {
-                    if (isObject(condition[conditionKey])) {
-                        Object.assign(query, condition);
-                    }
-                    else {
-                        console.warn(`unmergable condition, query is object but condition is ${getType(condition)}, can only overwrite`, condition, key);
-                        query[conditionKey] = condition[conditionKey];
-                    }
-                }
-                else {
-                    console.warn(`to-merge query is of type ${getType(query)}, can only overwrite`, query, condition, key);
-                    query[conditionKey] = condition[conditionKey];
-                }
-            }
-            else {
-                query[conditionKey] = condition[conditionKey];
-            }
-        }
-    }
-}

package/dist/esm/serializer/update.d.ts

@@ -1,16 +0,0 @@
-import { UpdateCommand } from '../commands/update';
-import { LogicCommand } from '../commands/logic';
-export declare type IQueryCondition = Record<string, any> | LogicCommand;
-export interface IUpdateCondition {
-    [key: string]: any;
-}
-export declare class UpdateSerializer {
-    private constructor();
-    static encode(query: IQueryCondition | UpdateCommand): IUpdateCondition;
-    static encodeEJSON(query: IQueryCondition | UpdateCommand, raw: boolean): string;
-    encodeUpdate(query: IQueryCondition | UpdateCommand): IUpdateCondition;
-    encodeUpdateCommand(query: UpdateCommand): IQueryCondition;
-    encodeFieldUpdateCommand(query: UpdateCommand): IQueryCondition;
-    encodeArrayUpdateCommand(query: UpdateCommand): IQueryCondition;
-    encodeUpdateObject(query: Record<string, any>): IQueryCondition;
-}

package/dist/esm/serializer/update.js

@@ -1,139 +0,0 @@
-import { UpdateCommand, isUpdateCommand, UPDATE_COMMANDS_LITERAL } from '../commands/update';
-import { SYMBOL_UNSET_FIELD_NAME } from '../helper/symbol';
-import { getType, isArray } from '../utils/type';
-import { operatorToString } from '../operator-map';
-import { flattenQueryObject, encodeInternalDataType, mergeConditionAfterEncode } from './common';
-import { stringifyByEJSON } from '../utils/utils';
-export class UpdateSerializer {
-    constructor() { }
-    static encode(query) {
-        const stringifier = new UpdateSerializer();
-        return stringifier.encodeUpdate(query);
-    }
-    static encodeEJSON(query, raw) {
-        const stringifier = new UpdateSerializer();
-        return stringifyByEJSON(raw ? query : stringifier.encodeUpdate(query));
-    }
-    encodeUpdate(query) {
-        if (isUpdateCommand(query)) {
-            return this.encodeUpdateCommand(query);
-        }
-        else if (getType(query) === 'object') {
-            return this.encodeUpdateObject(query);
-        }
-        else {
-            return query;
-        }
-    }
-    encodeUpdateCommand(query) {
-        if (query.fieldName === SYMBOL_UNSET_FIELD_NAME) {
-            throw new Error('Cannot encode a comparison command with unset field name');
-        }
-        switch (query.operator) {
-            case UPDATE_COMMANDS_LITERAL.PUSH:
-            case UPDATE_COMMANDS_LITERAL.PULL:
-            case UPDATE_COMMANDS_LITERAL.PULL_ALL:
-            case UPDATE_COMMANDS_LITERAL.POP:
-            case UPDATE_COMMANDS_LITERAL.SHIFT:
-            case UPDATE_COMMANDS_LITERAL.UNSHIFT:
-            case UPDATE_COMMANDS_LITERAL.ADD_TO_SET: {
-                return this.encodeArrayUpdateCommand(query);
-            }
-            default: {
-                return this.encodeFieldUpdateCommand(query);
-            }
-        }
-    }
-    encodeFieldUpdateCommand(query) {
-        const $op = operatorToString(query.operator);
-        switch (query.operator) {
-            case UPDATE_COMMANDS_LITERAL.REMOVE: {
-                return {
-                    [$op]: {
-                        [query.fieldName]: ''
-                    }
-                };
-            }
-            default: {
-                return {
-                    [$op]: {
-                        [query.fieldName]: query.operands[0]
-                    }
-                };
-            }
-        }
-    }
-    encodeArrayUpdateCommand(query) {
-        const $op = operatorToString(query.operator);
-        switch (query.operator) {
-            case UPDATE_COMMANDS_LITERAL.PUSH: {
-                let modifiers;
-                if (isArray(query.operands)) {
-                    modifiers = {
-                        $each: query.operands.map(encodeInternalDataType)
-                    };
-                }
-                else {
-                    modifiers = query.operands;
-                }
-                return {
-                    [$op]: {
-                        [query.fieldName]: modifiers
-                    }
-                };
-            }
-            case UPDATE_COMMANDS_LITERAL.UNSHIFT: {
-                const modifiers = {
-                    $each: query.operands.map(encodeInternalDataType),
-                    $position: 0
-                };
-                return {
-                    [$op]: {
-                        [query.fieldName]: modifiers
-                    }
-                };
-            }
-            case UPDATE_COMMANDS_LITERAL.POP: {
-                return {
-                    [$op]: {
-                        [query.fieldName]: 1
-                    }
-                };
-            }
-            case UPDATE_COMMANDS_LITERAL.SHIFT: {
-                return {
-                    [$op]: {
-                        [query.fieldName]: -1
-                    }
-                };
-            }
-            default: {
-                return {
-                    [$op]: {
-                        [query.fieldName]: encodeInternalDataType(query.operands)
-                    }
-                };
-            }
-        }
-    }
-    encodeUpdateObject(query) {
-        const flattened = flattenQueryObject(query);
-        for (const key in flattened) {
-            if (/^\$/.test(key))
-                continue;
-            let val = flattened[key];
-            if (isUpdateCommand(val)) {
-                flattened[key] = val._setFieldName(key);
-                const condition = this.encodeUpdateCommand(flattened[key]);
-                mergeConditionAfterEncode(flattened, condition, key);
-            }
-            else {
-                flattened[key] = val = encodeInternalDataType(val);
-                const $setCommand = new UpdateCommand(UPDATE_COMMANDS_LITERAL.SET, [val], key);
-                const condition = this.encodeUpdateCommand($setCommand);
-                mergeConditionAfterEncode(flattened, condition, key);
-            }
-        }
-        return flattened;
-    }
-}

package/dist/esm/serverDate/index.d.ts

@@ -1,13 +0,0 @@
-export declare class ServerDate {
-    readonly offset: number;
-    constructor({ offset }?: {
-        offset?: number;
-    });
-    readonly _internalType: import("../utils/symbol").InternalSymbol;
-    parse(): {
-        $tcb_server_date: {
-            offset: number;
-        };
-    };
-}
-export declare function ServerDateConstructor(opt: any): ServerDate;

package/dist/esm/serverDate/index.js

@@ -1,19 +0,0 @@
-import { SYMBOL_SERVER_DATE } from '../helper/symbol';
-export class ServerDate {
-    constructor({ offset = 0 } = {}) {
-        this.offset = offset;
-    }
-    get _internalType() {
-        return SYMBOL_SERVER_DATE;
-    }
-    parse() {
-        return {
-            $tcb_server_date: {
-                offset: this.offset
-            }
-        };
-    }
-}
-export function ServerDateConstructor(opt) {
-    return new ServerDate(opt);
-}

package/dist/esm/transaction/index.d.ts

@@ -1,30 +0,0 @@
-import { Db } from '../index';
-import { CollectionReference } from '../collection';
-interface TransactionAPI {
-    send(interfaceName: string, param?: any): any;
-}
-export declare class Transaction {
-    private _id;
-    private _db;
-    private _request;
-    aborted: boolean;
-    abortReason: any;
-    commited: boolean;
-    inited: boolean;
-    constructor(db: Db);
-    init(): Promise<void>;
-    collection(collName: string): CollectionReference;
-    getTransactionId(): string;
-    getRequestMethod(): TransactionAPI;
-    commit(): Promise<CommitResult>;
-    rollback(customRollbackRes: any): Promise<RollbackResult>;
-}
-export declare function startTransaction(): Promise<Transaction>;
-export declare function runTransaction(callback: (transaction: Transaction) => void | Promise<any>, times?: number): Promise<any>;
-interface CommitResult {
-    requestId: string;
-}
-interface RollbackResult {
-    requestId: string;
-}
-export {};

package/dist/esm/transaction/index.js

@@ -1,100 +0,0 @@
-import { Db } from '../index';
-import { CollectionReference } from '../collection';
-import { ERRORS } from '../const/code';
-const START = 'database.startTransaction';
-const COMMIT = 'database.commitTransaction';
-const ABORT = 'database.abortTransaction';
-export class Transaction {
-    constructor(db) {
-        this._db = db;
-        this._request = new Db.reqClass(this._db.config);
-        this.aborted = false;
-        this.commited = false;
-        this.inited = false;
-    }
-    async init() {
-        const res = await this._request.send(START);
-        if (res.code) {
-            throw res;
-        }
-        this.inited = true;
-        this._id = res.transactionId;
-    }
-    collection(collName) {
-        if (!collName) {
-            throw new Error('Collection name is required');
-        }
-        return new CollectionReference(this._db, collName, {}, this._id);
-    }
-    getTransactionId() {
-        return this._id;
-    }
-    getRequestMethod() {
-        return this._request;
-    }
-    async commit() {
-        const param = {
-            transactionId: this._id
-        };
-        const res = await this._request.send(COMMIT, param);
-        if (res.code)
-            throw res;
-        this.commited = true;
-        return res;
-    }
-    async rollback(customRollbackRes) {
-        const param = {
-            transactionId: this._id
-        };
-        const res = await this._request.send(ABORT, param);
-        if (res.code)
-            throw res;
-        this.aborted = true;
-        this.abortReason = customRollbackRes;
-        return res;
-    }
-}
-export async function startTransaction() {
-    const transaction = new Transaction(this);
-    await transaction.init();
-    return transaction;
-}
-export async function runTransaction(callback, times = 3) {
-    let transaction;
-    try {
-        transaction = new Transaction(this);
-        await transaction.init();
-        const callbackRes = await callback(transaction);
-        if (transaction.aborted === true) {
-            throw transaction.abortReason;
-        }
-        await transaction.commit();
-        return callbackRes;
-    }
-    catch (error) {
-        if (transaction.inited === false) {
-            throw error;
-        }
-        const throwWithRollback = async (error) => {
-            if (!transaction.aborted && !transaction.commited) {
-                try {
-                    await transaction.rollback();
-                }
-                catch (err) {
-                }
-                throw error;
-            }
-            if (transaction.aborted === true) {
-                throw transaction.abortReason;
-            }
-            throw error;
-        };
-        if (times <= 0) {
-            await throwWithRollback(error);
-        }
-        if (error && error.code === ERRORS.DATABASE_TRANSACTION_CONFLICT.code) {
-            return await runTransaction.bind(this)(callback, --times);
-        }
-        await throwWithRollback(error);
-    }
-}

package/dist/esm/transaction.d.ts

@@ -1,42 +0,0 @@
-import { DocumentReference } from './document';
-import { Db } from './index';
-declare class DocumentSnapshot {
-    private _data;
-    requestId: string;
-    constructor(data: any, requestId: any);
-    data(): any;
-}
-export declare class Transaction {
-    private _id;
-    private _db;
-    private _request;
-    constructor(db: Db);
-    init(): Promise<void>;
-    get(documentRef: DocumentReference): Promise<DocumentSnapshot>;
-    set(documentRef: DocumentReference, data: Object): Promise<SetResult>;
-    update(documentRef: DocumentReference, data: Object): Promise<UpdateResult>;
-    delete(documentRef: DocumentReference): Promise<DeleteResult>;
-    commit(): Promise<CommitResult>;
-    rollback(): Promise<RollbackResult>;
-}
-export declare function startTransaction(): Promise<Transaction>;
-export declare function runTransaction(callback: (transaction: Transaction) => void | Promise<any>, times?: number): Promise<void>;
-declare type JsonString = string;
-interface CommitResult {
-    requestId: string;
-}
-interface RollbackResult {
-    requestId: string;
-}
-interface UpdateResult {
-    requestId: string;
-    updated: number;
-}
-interface SetResult extends UpdateResult {
-    upserted: JsonString;
-}
-interface DeleteResult {
-    requestId: string;
-    deleted: number | string;
-}
-export {};