@cloudbase/database 1.4.1 → 1.4.2

package/dist/esm/geo/index.js

@@ -1,6 +0,0 @@
-export * from './point';
-export * from './lineString';
-export * from './polygon';
-export * from './multiPoint';
-export * from './multiLineString';
-export * from './multiPolygon';

package/dist/esm/geo/interface.d.ts

@@ -1,24 +0,0 @@
-export interface ISerializedPoint {
-    type: string;
-    coordinates: [number, number];
-}
-export interface ISerializedLineString {
-    type: string;
-    coordinates: [number, number][];
-}
-export interface ISerializedPolygon {
-    type: string;
-    coordinates: [number, number][][];
-}
-export interface ISerializedMultiPoint {
-    type: string;
-    coordinates: [number, number][];
-}
-export interface ISerializedMultiLineString {
-    type: string;
-    coordinates: [number, number][][];
-}
-export interface ISerializedMultiPolygon {
-    type: string;
-    coordinates: [number, number][][][];
-}

package/dist/esm/geo/lineString.d.ts

@@ -1,19 +0,0 @@
-import { Point } from './point';
-import { ISerializedLineString } from './interface';
-export declare class LineString {
-    readonly points: Point[];
-    constructor(points: Point[]);
-    parse(key: any): {
-        [x: number]: {
-            type: string;
-            coordinates: number[][];
-        };
-    };
-    toJSON(): {
-        type: string;
-        coordinates: number[][];
-    };
-    static validate(lineString: ISerializedLineString): boolean;
-    static isClosed(lineString: LineString): boolean;
-    readonly _internalType: import("../utils/symbol").InternalSymbol;
-}

package/dist/esm/geo/lineString.js

@@ -1,54 +0,0 @@
-import { SYMBOL_GEO_LINE_STRING } from '../helper/symbol';
-import { Point } from './point';
-import { isArray, isNumber } from '../utils/type';
-export class LineString {
-    constructor(points) {
-        if (!isArray(points)) {
-            throw new TypeError(`"points" must be of type Point[]. Received type ${typeof points}`);
-        }
-        if (points.length < 2) {
-            throw new Error('"points" must contain 2 points at least');
-        }
-        points.forEach(point => {
-            if (!(point instanceof Point)) {
-                throw new TypeError(`"points" must be of type Point[]. Received type ${typeof point}[]`);
-            }
-        });
-        this.points = points;
-    }
-    parse(key) {
-        return {
-            [key]: {
-                type: 'LineString',
-                coordinates: this.points.map(point => point.toJSON().coordinates)
-            }
-        };
-    }
-    toJSON() {
-        return {
-            type: 'LineString',
-            coordinates: this.points.map(point => point.toJSON().coordinates)
-        };
-    }
-    static validate(lineString) {
-        if (lineString.type !== 'LineString' || !isArray(lineString.coordinates)) {
-            return false;
-        }
-        for (let point of lineString.coordinates) {
-            if (!isNumber(point[0]) || !isNumber(point[1])) {
-                return false;
-            }
-        }
-        return true;
-    }
-    static isClosed(lineString) {
-        const firstPoint = lineString.points[0];
-        const lastPoint = lineString.points[lineString.points.length - 1];
-        if (firstPoint.latitude === lastPoint.latitude && firstPoint.longitude === lastPoint.longitude) {
-            return true;
-        }
-    }
-    get _internalType() {
-        return SYMBOL_GEO_LINE_STRING;
-    }
-}

package/dist/esm/geo/multiLineString.d.ts

@@ -1,18 +0,0 @@
-import { LineString } from './lineString';
-import { ISerializedMultiLineString } from './interface';
-export declare class MultiLineString {
-    readonly lines: LineString[];
-    constructor(lines: LineString[]);
-    parse(key: any): {
-        [x: number]: {
-            type: string;
-            coordinates: number[][][];
-        };
-    };
-    toJSON(): {
-        type: string;
-        coordinates: number[][][];
-    };
-    static validate(multiLineString: ISerializedMultiLineString): boolean;
-    readonly _internalType: import("../utils/symbol").InternalSymbol;
-}

package/dist/esm/geo/multiLineString.js

@@ -1,53 +0,0 @@
-import { SYMBOL_GEO_MULTI_LINE_STRING } from '../helper/symbol';
-import { isArray, isNumber } from '../utils/type';
-import { LineString } from './lineString';
-export class MultiLineString {
-    constructor(lines) {
-        if (!isArray(lines)) {
-            throw new TypeError(`"lines" must be of type LineString[]. Received type ${typeof lines}`);
-        }
-        if (lines.length === 0) {
-            throw new Error('Polygon must contain 1 linestring at least');
-        }
-        lines.forEach(line => {
-            if (!(line instanceof LineString)) {
-                throw new TypeError(`"lines" must be of type LineString[]. Received type ${typeof line}[]`);
-            }
-        });
-        this.lines = lines;
-    }
-    parse(key) {
-        return {
-            [key]: {
-                type: 'MultiLineString',
-                coordinates: this.lines.map(line => {
-                    return line.points.map(point => [point.longitude, point.latitude]);
-                })
-            }
-        };
-    }
-    toJSON() {
-        return {
-            type: 'MultiLineString',
-            coordinates: this.lines.map(line => {
-                return line.points.map(point => [point.longitude, point.latitude]);
-            })
-        };
-    }
-    static validate(multiLineString) {
-        if (multiLineString.type !== 'MultiLineString' || !isArray(multiLineString.coordinates)) {
-            return false;
-        }
-        for (let line of multiLineString.coordinates) {
-            for (let point of line) {
-                if (!isNumber(point[0]) || !isNumber(point[1])) {
-                    return false;
-                }
-            }
-        }
-        return true;
-    }
-    get _internalType() {
-        return SYMBOL_GEO_MULTI_LINE_STRING;
-    }
-}

package/dist/esm/geo/multiPoint.d.ts

@@ -1,18 +0,0 @@
-import { Point } from './point';
-import { ISerializedMultiPoint } from './interface';
-export declare class MultiPoint {
-    readonly points: Point[];
-    constructor(points: Point[]);
-    parse(key: any): {
-        [x: number]: {
-            type: string;
-            coordinates: number[][];
-        };
-    };
-    toJSON(): {
-        type: string;
-        coordinates: number[][];
-    };
-    static validate(multiPoint: ISerializedMultiPoint): boolean;
-    readonly _internalType: import("../utils/symbol").InternalSymbol;
-}

package/dist/esm/geo/multiPoint.js

@@ -1,47 +0,0 @@
-import { SYMBOL_GEO_MULTI_POINT } from '../helper/symbol';
-import { Point } from './point';
-import { isArray, isNumber } from '../utils/type';
-export class MultiPoint {
-    constructor(points) {
-        if (!isArray(points)) {
-            throw new TypeError(`"points" must be of type Point[]. Received type ${typeof points}`);
-        }
-        if (points.length === 0) {
-            throw new Error('"points" must contain 1 point at least');
-        }
-        points.forEach(point => {
-            if (!(point instanceof Point)) {
-                throw new TypeError(`"points" must be of type Point[]. Received type ${typeof point}[]`);
-            }
-        });
-        this.points = points;
-    }
-    parse(key) {
-        return {
-            [key]: {
-                type: 'MultiPoint',
-                coordinates: this.points.map(point => point.toJSON().coordinates)
-            }
-        };
-    }
-    toJSON() {
-        return {
-            type: 'MultiPoint',
-            coordinates: this.points.map(point => point.toJSON().coordinates)
-        };
-    }
-    static validate(multiPoint) {
-        if (multiPoint.type !== 'MultiPoint' || !isArray(multiPoint.coordinates)) {
-            return false;
-        }
-        for (let point of multiPoint.coordinates) {
-            if (!isNumber(point[0]) || !isNumber(point[1])) {
-                return false;
-            }
-        }
-        return true;
-    }
-    get _internalType() {
-        return SYMBOL_GEO_MULTI_POINT;
-    }
-}

package/dist/esm/geo/multiPolygon.d.ts

@@ -1,18 +0,0 @@
-import { Polygon } from './polygon';
-import { ISerializedMultiPolygon } from './interface';
-export declare class MultiPolygon {
-    readonly polygons: Polygon[];
-    constructor(polygons: Polygon[]);
-    parse(key: any): {
-        [x: number]: {
-            type: string;
-            coordinates: number[][][][];
-        };
-    };
-    toJSON(): {
-        type: string;
-        coordinates: number[][][][];
-    };
-    static validate(multiPolygon: ISerializedMultiPolygon): boolean;
-    readonly _internalType: import("../utils/symbol").InternalSymbol;
-}

package/dist/esm/geo/multiPolygon.js

@@ -1,59 +0,0 @@
-import { SYMBOL_GEO_MULTI_POLYGON } from '../helper/symbol';
-import { isArray, isNumber } from '../utils/type';
-import { Polygon } from './polygon';
-export class MultiPolygon {
-    constructor(polygons) {
-        if (!isArray(polygons)) {
-            throw new TypeError(`"polygons" must be of type Polygon[]. Received type ${typeof polygons}`);
-        }
-        if (polygons.length === 0) {
-            throw new Error('MultiPolygon must contain 1 polygon at least');
-        }
-        for (let polygon of polygons) {
-            if (!(polygon instanceof Polygon)) {
-                throw new TypeError(`"polygon" must be of type Polygon[]. Received type ${typeof polygon}[]`);
-            }
-        }
-        this.polygons = polygons;
-    }
-    parse(key) {
-        return {
-            [key]: {
-                type: 'MultiPolygon',
-                coordinates: this.polygons.map(polygon => {
-                    return polygon.lines.map(line => {
-                        return line.points.map(point => [point.longitude, point.latitude]);
-                    });
-                })
-            }
-        };
-    }
-    toJSON() {
-        return {
-            type: 'MultiPolygon',
-            coordinates: this.polygons.map(polygon => {
-                return polygon.lines.map(line => {
-                    return line.points.map(point => [point.longitude, point.latitude]);
-                });
-            })
-        };
-    }
-    static validate(multiPolygon) {
-        if (multiPolygon.type !== 'MultiPolygon' || !isArray(multiPolygon.coordinates)) {
-            return false;
-        }
-        for (let polygon of multiPolygon.coordinates) {
-            for (let line of polygon) {
-                for (let point of line) {
-                    if (!isNumber(point[0]) || !isNumber(point[1])) {
-                        return false;
-                    }
-                }
-            }
-        }
-        return true;
-    }
-    get _internalType() {
-        return SYMBOL_GEO_MULTI_POLYGON;
-    }
-}

package/dist/esm/geo/point.d.ts

@@ -1,19 +0,0 @@
-import { ISerializedPoint } from './interface';
-export declare class Point {
-    readonly latitude: number;
-    readonly longitude: number;
-    constructor(longitude: number, latitude: number);
-    parse(key: any): {
-        [x: number]: {
-            type: string;
-            coordinates: number[];
-        };
-    };
-    toJSON(): {
-        type: string;
-        coordinates: number[];
-    };
-    toReadableString(): string;
-    static validate(point: ISerializedPoint): boolean;
-    readonly _internalType: import("../utils/symbol").InternalSymbol;
-}

package/dist/esm/geo/point.js

@@ -1,40 +0,0 @@
-import { Validate } from '../validate';
-import { SYMBOL_GEO_POINT } from '../helper/symbol';
-import { isArray } from '../utils/type';
-export class Point {
-    constructor(longitude, latitude) {
-        Validate.isGeopoint('longitude', longitude);
-        Validate.isGeopoint('latitude', latitude);
-        this.longitude = longitude;
-        this.latitude = latitude;
-    }
-    parse(key) {
-        return {
-            [key]: {
-                type: 'Point',
-                coordinates: [this.longitude, this.latitude]
-            }
-        };
-    }
-    toJSON() {
-        return {
-            type: 'Point',
-            coordinates: [
-                this.longitude,
-                this.latitude,
-            ],
-        };
-    }
-    toReadableString() {
-        return `[${this.longitude},${this.latitude}]`;
-    }
-    static validate(point) {
-        return point.type === 'Point' &&
-            isArray(point.coordinates) &&
-            Validate.isGeopoint('longitude', point.coordinates[0]) &&
-            Validate.isGeopoint('latitude', point.coordinates[1]);
-    }
-    get _internalType() {
-        return SYMBOL_GEO_POINT;
-    }
-}

package/dist/esm/geo/polygon.d.ts

@@ -1,19 +0,0 @@
-import { LineString } from './lineString';
-import { ISerializedPolygon } from './interface';
-export declare class Polygon {
-    readonly lines: LineString[];
-    constructor(lines: LineString[]);
-    parse(key: any): {
-        [x: number]: {
-            type: string;
-            coordinates: number[][][];
-        };
-    };
-    toJSON(): {
-        type: string;
-        coordinates: number[][][];
-    };
-    static validate(polygon: ISerializedPolygon): boolean;
-    static isCloseLineString(lineString: any): boolean;
-    readonly _internalType: import("../utils/symbol").InternalSymbol;
-}

package/dist/esm/geo/polygon.js

@@ -1,67 +0,0 @@
-import { SYMBOL_GEO_POLYGON } from '../helper/symbol';
-import { isArray, isNumber } from '../utils/type';
-import { LineString } from './lineString';
-export class Polygon {
-    constructor(lines) {
-        if (!isArray(lines)) {
-            throw new TypeError(`"lines" must be of type LineString[]. Received type ${typeof lines}`);
-        }
-        if (lines.length === 0) {
-            throw new Error('Polygon must contain 1 linestring at least');
-        }
-        lines.forEach(line => {
-            if (!(line instanceof LineString)) {
-                throw new TypeError(`"lines" must be of type LineString[]. Received type ${typeof line}[]`);
-            }
-            if (!LineString.isClosed(line)) {
-                throw new Error(`LineString ${line.points.map(p => p.toReadableString())} is not a closed cycle`);
-            }
-        });
-        this.lines = lines;
-    }
-    parse(key) {
-        return {
-            [key]: {
-                type: 'Polygon',
-                coordinates: this.lines.map(line => {
-                    return line.points.map(point => [point.longitude, point.latitude]);
-                })
-            }
-        };
-    }
-    toJSON() {
-        return {
-            type: 'Polygon',
-            coordinates: this.lines.map(line => {
-                return line.points.map(point => [point.longitude, point.latitude]);
-            })
-        };
-    }
-    static validate(polygon) {
-        if (polygon.type !== 'Polygon' || !isArray(polygon.coordinates)) {
-            return false;
-        }
-        for (let line of polygon.coordinates) {
-            if (!this.isCloseLineString(line)) {
-                return false;
-            }
-            for (let point of line) {
-                if (!isNumber(point[0]) || !isNumber(point[1])) {
-                    return false;
-                }
-            }
-        }
-        return true;
-    }
-    static isCloseLineString(lineString) {
-        const firstPoint = lineString[0];
-        const lastPoint = lineString[lineString.length - 1];
-        if (firstPoint[0] !== lastPoint[0] || firstPoint[1] !== lastPoint[1]) {
-            return false;
-        }
-        return true;
-    }
-    get _internalType() {
-        return SYMBOL_GEO_POLYGON;
-    }
-}

package/dist/esm/helper/symbol.d.ts

@@ -1,15 +0,0 @@
-import InternalSymbol from '../utils/symbol';
-export * from '../utils/symbol';
-export declare const SYMBOL_UNSET_FIELD_NAME: InternalSymbol;
-export declare const SYMBOL_UPDATE_COMMAND: InternalSymbol;
-export declare const SYMBOL_QUERY_COMMAND: InternalSymbol;
-export declare const SYMBOL_LOGIC_COMMAND: InternalSymbol;
-export declare const SYMBOL_GEO_POINT: InternalSymbol;
-export declare const SYMBOL_GEO_LINE_STRING: InternalSymbol;
-export declare const SYMBOL_GEO_POLYGON: InternalSymbol;
-export declare const SYMBOL_GEO_MULTI_POINT: InternalSymbol;
-export declare const SYMBOL_GEO_MULTI_LINE_STRING: InternalSymbol;
-export declare const SYMBOL_GEO_MULTI_POLYGON: InternalSymbol;
-export declare const SYMBOL_SERVER_DATE: InternalSymbol;
-export declare const SYMBOL_REGEXP: InternalSymbol;
-export declare const SYMBOL_OBJECTID: InternalSymbol;

package/dist/esm/helper/symbol.js

@@ -1,15 +0,0 @@
-import InternalSymbol from '../utils/symbol';
-export * from '../utils/symbol';
-export const SYMBOL_UNSET_FIELD_NAME = InternalSymbol.for('UNSET_FIELD_NAME');
-export const SYMBOL_UPDATE_COMMAND = InternalSymbol.for('UPDATE_COMMAND');
-export const SYMBOL_QUERY_COMMAND = InternalSymbol.for('QUERY_COMMAND');
-export const SYMBOL_LOGIC_COMMAND = InternalSymbol.for('LOGIC_COMMAND');
-export const SYMBOL_GEO_POINT = InternalSymbol.for('GEO_POINT');
-export const SYMBOL_GEO_LINE_STRING = InternalSymbol.for('SYMBOL_GEO_LINE_STRING');
-export const SYMBOL_GEO_POLYGON = InternalSymbol.for('SYMBOL_GEO_POLYGON');
-export const SYMBOL_GEO_MULTI_POINT = InternalSymbol.for('SYMBOL_GEO_MULTI_POINT');
-export const SYMBOL_GEO_MULTI_LINE_STRING = InternalSymbol.for('SYMBOL_GEO_MULTI_LINE_STRING');
-export const SYMBOL_GEO_MULTI_POLYGON = InternalSymbol.for('SYMBOL_GEO_MULTI_POLYGON');
-export const SYMBOL_SERVER_DATE = InternalSymbol.for('SERVER_DATE');
-export const SYMBOL_REGEXP = InternalSymbol.for('REGEXP');
-export const SYMBOL_OBJECTID = InternalSymbol.for('OBJECTID');

package/dist/esm/index.d.ts

@@ -1,50 +0,0 @@
-import { Point } from './geo/point';
-import { CollectionReference } from './collection';
-import { Command } from './command';
-interface GeoTeyp {
-    Point: typeof Point;
-}
-export { Query } from './query';
-export { CollectionReference } from './collection';
-export { DocumentReference } from './document';
-interface ICloudBaseConfig {
-    timeout?: number;
-    isHttp?: boolean;
-    secretId?: string;
-    secretKey?: string;
-    envName?: string;
-    env?: string;
-    sessionToken?: string;
-    serviceUrl?: string;
-    headers?: any;
-    proxy?: string;
-    version?: string;
-    credentials?: ICredentialsInfo;
-    _useFeature?: boolean;
-    throwOnCode?: boolean;
-}
-interface ICredentialsInfo {
-    private_key_id: string;
-    private_key: string;
-}
-export declare class Db {
-    Geo: GeoTeyp;
-    command: typeof Command;
-    RegExp: any;
-    serverDate: any;
-    ObjectId: any;
-    startTransaction: any;
-    runTransaction: any;
-    config: ICloudBaseConfig;
-    static ws: any;
-    static reqClass: any;
-    static wsClass: any;
-    static createSign: Function;
-    static getAccessToken: Function;
-    static dataVersion: string;
-    static runtime: string;
-    static appSecretInfo: any;
-    constructor(config?: any);
-    collection(collName: string): CollectionReference;
-    createCollection(collName: string): any;
-}

package/dist/esm/index.js

@@ -1,35 +0,0 @@
-import * as Geo from './geo/index';
-import { CollectionReference } from './collection';
-import { Command } from './command';
-import { ServerDateConstructor } from './serverDate/index';
-import { RegExpConstructor } from './regexp/index';
-import { startTransaction, runTransaction } from './transaction/index';
-import { ObjectIdConstructor } from './ObjectId/index';
-export { Query } from './query';
-export { CollectionReference } from './collection';
-export { DocumentReference } from './document';
-export class Db {
-    constructor(config) {
-        this.config = config;
-        this.Geo = Geo;
-        this.serverDate = ServerDateConstructor;
-        this.command = Command;
-        this.RegExp = RegExpConstructor;
-        this.ObjectId = ObjectIdConstructor;
-        this.startTransaction = startTransaction;
-        this.runTransaction = runTransaction;
-    }
-    collection(collName) {
-        if (!collName) {
-            throw new Error('Collection name is required');
-        }
-        return new CollectionReference(this, collName);
-    }
-    createCollection(collName) {
-        let request = new Db.reqClass(this.config);
-        const params = {
-            collectionName: collName
-        };
-        return request.send('database.addCollection', params);
-    }
-}

package/dist/esm/operator-map.d.ts

@@ -1,4 +0,0 @@
-export declare const OperatorMap: {
-    [key: string]: string;
-};
-export declare function operatorToString(operator: string): string;

package/dist/esm/operator-map.js

@@ -1,20 +0,0 @@
-import { QUERY_COMMANDS_LITERAL } from './commands/query';
-import { LOGIC_COMMANDS_LITERAL } from './commands/logic';
-import { UPDATE_COMMANDS_LITERAL } from './commands/update';
-export const OperatorMap = {};
-for (const key in QUERY_COMMANDS_LITERAL) {
-    OperatorMap[key] = '$' + key;
-}
-for (const key in LOGIC_COMMANDS_LITERAL) {
-    OperatorMap[key] = '$' + key;
-}
-for (const key in UPDATE_COMMANDS_LITERAL) {
-    OperatorMap[key] = '$' + key;
-}
-OperatorMap[QUERY_COMMANDS_LITERAL.NEQ] = '$ne';
-OperatorMap[UPDATE_COMMANDS_LITERAL.REMOVE] = '$unset';
-OperatorMap[UPDATE_COMMANDS_LITERAL.SHIFT] = '$pop';
-OperatorMap[UPDATE_COMMANDS_LITERAL.UNSHIFT] = '$push';
-export function operatorToString(operator) {
-    return OperatorMap[operator] || '$' + operator;
-}

package/dist/esm/query.d.ts

@@ -1,38 +0,0 @@
-import { OrderByDirection } from './constant';
-import { IWatchOptions, DBRealtimeListener } from './typings/index';
-interface GetRes {
-    data: any[];
-    requestId: string;
-    total: number;
-    limit: number;
-    offset: number;
-}
-interface BaseOption {
-    timeout?: number;
-    raw?: boolean;
-}
-export interface QueryOption extends BaseOption {
-    limit?: number;
-    offset?: number;
-    projection?: Object;
-    order?: Record<string, any>[];
-}
-export interface UpdateOption extends BaseOption {
-    multiple?: boolean;
-}
-export declare class Query {
-    protected _transactionId: string;
-    get(): Promise<GetRes>;
-    count(): Promise<any>;
-    where(query: object): Query;
-    options(apiOptions: QueryOption | UpdateOption): Query;
-    orderBy(fieldPath: string, directionStr: OrderByDirection): Query;
-    limit(limit: number): Query;
-    skip(offset: number): Query;
-    update(data: Object): Promise<any>;
-    field(projection: any): Query;
-    remove(): Promise<any>;
-    updateAndReturn(data: Object): Promise<any>;
-    watch: (options: IWatchOptions) => DBRealtimeListener;
-}
-export {};