@syntropix/database 0.1.0 → 0.1.1

package/dist/index.d.ts

@@ -1,9 +1,620 @@
-export { Client } from './core/client';
-export * from './core/config';
-export { SyntropixClient } from './core/syntropix';
-export { BaseModel, Column, ForeignKey } from './types/basemodel';
-export * from './types/common';
-export { ColumnType } from './types/data-type';
-export * from './types/field';
-export * from './types/filter';
-export * from './types/requests';
+declare class ClientConfig {
+    apiKey?: string;
+    baseUrl?: string;
+    timeout?: number;
+    retries?: number;
+    constructor(config?: any);
+}
+
+declare class Client {
+    protected config: ClientConfig;
+    constructor(config: ClientConfig);
+    private headers;
+    private url;
+    get(path: string, data?: Record<string, any>): Promise<Record<string, any>>;
+    post(path: string, data?: Record<string, any>): Promise<Record<string, any>>;
+}
+
+interface StringType {
+    String: number;
+}
+interface VectorType {
+    Vector: number;
+}
+interface EnumType {
+    Enum: {
+        name: string;
+        variants: string[];
+    };
+}
+interface MoneyType {
+    Money: [number, number] | null;
+}
+interface DecimalType {
+    Decimal: [number, number] | null;
+}
+type ArrayDataTypeMap = typeof ArrayDataType;
+type ArrayDataTypeValues = ArrayDataTypeMap[keyof ArrayDataTypeMap];
+type ArrayDataTypeReturnTypes = ReturnType<Extract<ArrayDataTypeValues, (...args: any[]) => any>>;
+declare const ArrayDataType: {
+    readonly String: (maxLength: number) => StringType;
+    readonly Text: "Text";
+    readonly Integer: "Integer";
+    readonly BigInteger: "BigInteger";
+    readonly Double: "Double";
+    readonly Decimal: (precision: number, scale: number) => DecimalType;
+    readonly DateTime: "DateTime";
+    readonly Timestamp: "Timestamp";
+    readonly Date: "Date";
+    readonly Boolean: "Boolean";
+    readonly Money: (precision: number, scale: number) => MoneyType;
+    readonly Uuid: "Uuid";
+    readonly Enum: (name: string, variants: string[]) => EnumType;
+    readonly Json: "Json";
+};
+type ArrayDataType = Exclude<ArrayDataTypeValues, (...args: any[]) => any> | ArrayDataTypeReturnTypes;
+interface ArrayType {
+    Array: ArrayDataType;
+}
+type DataTypeMap = typeof ColumnDataType;
+type DataTypeValues = DataTypeMap[keyof DataTypeMap];
+type DataTypeReturnTypes = ReturnType<Extract<DataTypeValues, (...args: any[]) => any>>;
+declare const ColumnDataType: {
+    readonly Integer: "Integer";
+    readonly String: (maxLength: number) => StringType;
+    readonly Text: "Text";
+    readonly Boolean: "Boolean";
+    readonly DateTime: "DateTime";
+    readonly Timestamp: "Timestamp";
+    readonly Date: "Date";
+    readonly Json: "Json";
+    readonly Uuid: "Uuid";
+    readonly Double: "Double";
+    readonly Vector: (dimensions: number) => VectorType;
+    readonly Array: (dataType: ArrayDataType) => ArrayType;
+    readonly Enum: (name: string, variants: string[]) => EnumType;
+    readonly Money: (precision: number, scale: number) => MoneyType;
+    readonly Decimal: (precision: number, scale: number) => DecimalType;
+};
+type ColumnDataType = Exclude<DataTypeValues, (...args: any[]) => any> | DataTypeReturnTypes;
+
+declare enum SortType {
+    Descending = "Descending",
+    Ascending = "Ascending"
+}
+interface SimilarityOptions {
+    threshold: number;
+    order?: SortType;
+    alias?: string;
+}
+declare enum FilterOperation {
+    LT = "LT",
+    LTE = "LTE",
+    GT = "GT",
+    GTE = "GTE",
+    EQ = "EQ",
+    NEQ = "NEQ",
+    Between = "Between",
+    In = "In",
+    Contains = "Contains",
+    Overlap = "Overlap",
+    NotIn = "NotIn",
+    Like = "Like",
+    NotLike = "NotLike",
+    ILike = "ILike",
+    NotILike = "NotILike",
+    IsNull = "IsNull",
+    IsNotNull = "IsNotNull",
+    Similarity = "Similarity",
+    SimilarityDistance = "SimilarityDistance",
+    WordSimilarity = "WordSimilarity",
+    WordSimilarityDistance = "WordSimilarityDistance",
+    StrictWordSimilarity = "StrictWordSimilarity",
+    StrictWordSimilarityDistance = "StrictWordSimilarityDistance",
+    EuclideanDistance = "EuclideanDistance",
+    NegativeInnerProduct = "NegativeInnerProduct",
+    CosineDistance = "CosineDistance"
+}
+interface FilterItem {
+    column: string;
+    operator: FilterOperation;
+    staticValue?: any;
+    columnValue?: string;
+    simiarityOptions?: SimilarityOptions;
+}
+type FilterGroup = FilterItem[];
+type Filter = FilterGroup[];
+declare const AND: (...conditions: FilterItem[]) => FilterGroup;
+declare const OR: (...conditions: FilterGroup[]) => Filter;
+declare const EQ: (field: string, value: any) => FilterItem;
+declare const NE: (field: string, value: any) => FilterItem;
+declare const GT: (field: string, value: any) => FilterItem;
+declare const GTE: (field: string, value: any) => FilterItem;
+declare const LT: (field: string, value: any) => FilterItem;
+declare const LTE: (field: string, value: any) => FilterItem;
+declare const IN: (field: string, values: any[]) => FilterItem;
+declare const CONTAINS: (field: string, value: any) => FilterItem;
+declare const OVERLAP: (field: string, value: any) => FilterItem;
+declare const I_LIKE: (field: string, pattern: string) => FilterItem;
+declare const NOT_I_LIKE: (field: string, pattern: string) => FilterItem;
+declare const NOT_IN: (field: string, values: any[]) => FilterItem;
+declare const LIKE: (field: string, pattern: string) => FilterItem;
+declare const NOT_LIKE: (field: string, pattern: string) => FilterItem;
+declare const IS_NULL: (field: string) => FilterItem;
+declare const IS_NOT_NULL: (field: string) => FilterItem;
+declare const BETWEEN: (field: string, min: any, max: any) => FilterItem;
+declare const EQ_COL: (field: string, otherField: string) => FilterItem;
+declare const NE_COL: (field: string, otherField: string) => FilterItem;
+declare const GT_COL: (field: string, otherField: string) => FilterItem;
+declare const GTE_COL: (field: string, otherField: string) => FilterItem;
+declare const LT_COL: (field: string, otherField: string) => FilterItem;
+declare const LTE_COL: (field: string, otherField: string) => FilterItem;
+declare const SIMILARITY: (field: string, value: any, options: SimilarityOptions) => FilterItem;
+declare const SIMILARITY_DISTANCE: (field: string, value: any, options: SimilarityOptions) => FilterItem;
+declare const WORD_SIMILARITY: (field: string, value: any, options: SimilarityOptions) => FilterItem;
+declare const WORD_SIMILARITY_DISTANCE: (field: string, value: any, options: SimilarityOptions) => FilterItem;
+declare const STRICT_WORD_SIMILARITY: (field: string, value: any, options: SimilarityOptions) => FilterItem;
+declare const STRICT_WORD_SIMILARITY_DISTANCE: (field: string, value: any, options: SimilarityOptions) => FilterItem;
+declare const EUCLIDEAN_DISTANCE: (field: string, value: any, options: SimilarityOptions) => FilterItem;
+declare const NEGATIVE_INNER_PRODUCT: (field: string, value: any, options: SimilarityOptions) => FilterItem;
+declare const COSINE_DISTANCE: (field: string, value: any, options: SimilarityOptions) => FilterItem;
+declare const Value: (value: any) => any;
+declare function FilterWrapper(filter: Filter | FilterGroup | FilterItem | undefined): Filter | undefined;
+
+declare enum ForeignKeyAction {
+    Cascade = "Cascade",
+    Restrict = "Restrict",
+    SetNull = "SetNull",
+    NoAction = "NoAction",
+    SetDefault = "SetDefault"
+}
+declare enum AggregateFunction {
+    Count = "Count",
+    Sum = "Sum",
+    Avg = "Avg",
+    Min = "Min",
+    Max = "Max",
+    CountDistinct = "CountDistinct"
+}
+interface Sort {
+    column: string;
+    direction: SortType;
+}
+interface Join {
+    table: string;
+    on: any;
+}
+interface Aggregate {
+    column: string;
+    function: AggregateFunction;
+    alias: string;
+}
+interface GroupBy {
+    columns: string[];
+}
+interface ForeignKey$1 {
+    name?: string;
+    fromTableName: string;
+    fromColumnName: string;
+    toTableName: string;
+    toColumnName: string;
+    onDelete?: ForeignKeyAction;
+    onUpdate?: ForeignKeyAction;
+}
+interface Column$1 {
+    name: string;
+    displayName?: string;
+    description?: string;
+    columnType: ColumnDataType;
+    isPrimaryKey?: boolean;
+    isNullable?: boolean;
+    autoIncrement?: boolean;
+    default?: any;
+    defaultAccess?: SyntropixDBAccessType;
+}
+interface Index {
+    name: string;
+    columns: string[];
+    unique?: boolean;
+}
+interface SyntropixDBTable {
+    id: string;
+    name: string;
+    description: string;
+    createdAt: Date;
+    columns: Column$1[];
+}
+interface SyntropixDBTableListItem {
+    id: string;
+    name: string;
+    description: string;
+    metadata: Record<string, any>;
+    path: string;
+    visible: boolean;
+    access: SyntropixDBAccessType;
+}
+
+declare const SyntropixDBAccessType: {
+    readonly None: "None";
+    readonly Read: "Read";
+    readonly Write: "Write";
+    readonly Admin: "Admin";
+};
+type SyntropixDBAccessType = (typeof SyntropixDBAccessType)[keyof typeof SyntropixDBAccessType];
+interface TableCreate {
+    name: string;
+    displayName?: string;
+    description?: string;
+    columns: Column$1[];
+    foreignKeys: ForeignKey$1[];
+    indexes: Index[];
+    defaultAccess?: SyntropixDBAccessType;
+    metadata?: Record<string, any>;
+    visible?: boolean;
+    path?: string;
+}
+interface TableDrop {
+    tableName: string;
+}
+interface TableRename {
+    tableName: string;
+    newTableName: string;
+}
+interface TableTruncate {
+    tableName: string;
+}
+interface TableAddColumn {
+    tableName: string;
+    column: Column$1;
+}
+interface TableDropColumn {
+    tableName: string;
+    columnName: string;
+}
+interface TableModifyColumn {
+    tableName: string;
+    column: Column$1;
+}
+interface TableGetSchema {
+    tableName: string;
+}
+interface TableGetList {
+    search?: string;
+    path?: string;
+    page?: number;
+    pageSize?: number;
+}
+interface InsertData {
+    columns: string[];
+    values: any[][];
+}
+interface Insert {
+    tableName: string;
+    data: InsertData;
+}
+interface UpdatePayload {
+    filter: Filter;
+    columns: string[];
+    values: any[];
+}
+interface Update {
+    tableName: string;
+    payload: UpdatePayload;
+}
+interface DeleteDataPayload {
+    filter: Filter;
+}
+interface DeleteData {
+    tableName: string;
+    payload: DeleteDataPayload;
+}
+interface QueryPayload {
+    filter?: Filter | FilterGroup | FilterItem;
+    sort?: Sort[];
+    aggregate?: Aggregate[];
+    join?: Join[];
+    limit?: number;
+    offset?: number;
+    groupBy?: GroupBy;
+    select?: string[];
+}
+interface Query {
+    tableName: string;
+    query: QueryPayload;
+}
+
+declare class DataClient {
+    private client;
+    constructor(config?: ClientConfig);
+    insertData(data: Insert): Promise<any>;
+    insertOne(data: Insert): Promise<any>;
+    updateByPrimaryKey(pk: string, data: Update): Promise<any>;
+    queryOne(data: Query, model?: any): Promise<any>;
+    queryMany(data: Query, model?: any): Promise<any>;
+    updateData(data: Update): Promise<any>;
+    deleteData(data: DeleteData): Promise<any>;
+}
+
+interface TableCreateResponse {
+    _id: {
+        $oid: string;
+    };
+    table: {
+        id: string;
+        name: string;
+        description: string;
+        createdAt: any;
+        columns: Column$1[];
+        foreignKeys: ForeignKey$1[];
+        indexes: Index[];
+        schema: string;
+        defaultAccess: string | null;
+    };
+    createdAt: any;
+    updatedAt: any;
+    createdBy: string;
+    metadata: Record<string, any>;
+    triggers: any[];
+}
+
+declare class TableClient {
+    private client;
+    constructor(config?: ClientConfig);
+    createTable(data: TableCreate): Promise<TableCreateResponse>;
+    dropTable(data: TableDrop): Promise<any>;
+    renameTable(data: TableRename): Promise<any>;
+    truncateTable(data: TableTruncate): Promise<any>;
+    addColumn(data: TableAddColumn): Promise<any>;
+    dropColumn(data: TableDropColumn): Promise<any>;
+    modifyColumn(data: TableModifyColumn): Promise<any>;
+    getTableSchema(data: TableGetSchema): Promise<SyntropixDBTable>;
+    getTableList(data: TableGetList): Promise<SyntropixDBTableListItem[]>;
+}
+
+declare class SyntropixClient {
+    private config;
+    private _tableClient?;
+    private _dataClient?;
+    constructor(config?: ClientConfig);
+    get table(): TableClient;
+    get data(): DataClient;
+}
+
+declare abstract class Field {
+    name: string;
+    description: string;
+    columnType: ColumnDataType;
+    isPrimaryKey: boolean;
+    isNullable: boolean;
+    autoIncrement: boolean;
+    default?: any;
+    defaultAccess?: SyntropixDBAccessType;
+    constructor(columnType: ColumnDataType, options?: {
+        name?: string;
+        description?: string;
+        isPrimaryKey?: boolean;
+        isNullable?: boolean;
+        autoIncrement?: boolean;
+        default?: any;
+        defaultAccess?: SyntropixDBAccessType;
+    });
+    into(): Column$1;
+}
+declare class ForeignKeyField extends Field {
+    tableName: string;
+    columnName: string;
+    onDelete: ForeignKeyAction;
+    onUpdate: ForeignKeyAction;
+    constructor(columnType: ColumnDataType, tableName: string, columnName: string, options?: {
+        onDelete?: ForeignKeyAction;
+        onUpdate?: ForeignKeyAction;
+        description?: string;
+        isPrimaryKey?: boolean;
+        isNullable?: boolean;
+        default?: any;
+        defaultAccess?: SyntropixDBAccessType;
+    });
+}
+declare class StringField extends Field {
+    constructor(maxLength: number, options?: {
+        description?: string;
+        isPrimaryKey?: boolean;
+        isNullable?: boolean;
+        default?: string;
+        defaultAccess?: SyntropixDBAccessType;
+    });
+}
+declare class TextField extends Field {
+    constructor(options?: {
+        description?: string;
+        isPrimaryKey?: boolean;
+        isNullable?: boolean;
+        default?: string;
+        defaultAccess?: SyntropixDBAccessType;
+    });
+}
+declare class IntegerField extends Field {
+    constructor(options?: {
+        description?: string;
+        isPrimaryKey?: boolean;
+        isNullable?: boolean;
+        autoIncrement?: boolean;
+        default?: number;
+        defaultAccess?: SyntropixDBAccessType;
+    });
+}
+declare class BooleanField extends Field {
+    constructor(options?: {
+        description?: string;
+        isPrimaryKey?: boolean;
+        isNullable?: boolean;
+        default?: boolean;
+        defaultAccess?: SyntropixDBAccessType;
+    });
+}
+declare class DateTimeField extends Field {
+    constructor(options?: {
+        description?: string;
+        isPrimaryKey?: boolean;
+        isNullable?: boolean;
+        default?: Date;
+        defaultAccess?: SyntropixDBAccessType;
+    });
+}
+declare class TimestampField extends Field {
+    constructor(options?: {
+        description?: string;
+        isPrimaryKey?: boolean;
+        isNullable?: boolean;
+        default?: Date;
+        defaultAccess?: SyntropixDBAccessType;
+    });
+}
+declare class DateField extends Field {
+    constructor(options?: {
+        description?: string;
+        isPrimaryKey?: boolean;
+        isNullable?: boolean;
+        default?: Date;
+        defaultAccess?: SyntropixDBAccessType;
+    });
+}
+declare class JsonField extends Field {
+    constructor(options?: {
+        description?: string;
+        isPrimaryKey?: boolean;
+        isNullable?: boolean;
+        default?: Record<string, any>;
+        defaultAccess?: SyntropixDBAccessType;
+    });
+}
+declare class UuidField extends Field {
+    constructor(options?: {
+        description?: string;
+        isPrimaryKey?: boolean;
+        isNullable?: boolean;
+        default?: string;
+        defaultAccess?: SyntropixDBAccessType;
+    });
+}
+declare class VectorField extends Field {
+    constructor(dimensions: number, options?: {
+        description?: string;
+        isPrimaryKey?: boolean;
+        isNullable?: boolean;
+        default?: number[];
+        defaultAccess?: SyntropixDBAccessType;
+    });
+}
+declare class ArrayField extends Field {
+    constructor(dataType: ArrayDataType, options?: {
+        description?: string;
+        isPrimaryKey?: boolean;
+        isNullable?: boolean;
+        default?: any[];
+        defaultAccess?: SyntropixDBAccessType;
+    });
+}
+declare class EnumField extends Field {
+    constructor(name: string, variants: string[], options?: {
+        description?: string;
+        isPrimaryKey?: boolean;
+        isNullable?: boolean;
+        default?: string;
+        defaultAccess?: SyntropixDBAccessType;
+    });
+}
+declare class MoneyField extends Field {
+    constructor(precision: number, scale: number, options?: {
+        description?: string;
+        isPrimaryKey?: boolean;
+        isNullable?: boolean;
+        default?: number;
+        defaultAccess?: SyntropixDBAccessType;
+    });
+}
+declare class DecimalField extends Field {
+    constructor(precision: number, scale: number, options?: {
+        description?: string;
+        isPrimaryKey?: boolean;
+        isNullable?: boolean;
+        default?: number;
+        defaultAccess?: SyntropixDBAccessType;
+    });
+}
+declare class DoubleField extends Field {
+    constructor(options?: {
+        description?: string;
+        isPrimaryKey?: boolean;
+        isNullable?: boolean;
+        default?: number;
+        defaultAccess?: SyntropixDBAccessType;
+    });
+}
+
+declare function Column(options?: {
+    type?: ColumnDataType;
+    name?: string;
+    description?: string;
+    primary?: boolean;
+    nullable?: boolean;
+    autoIncrement?: boolean;
+    default?: any;
+}): (target: any, propertyKey: string) => void;
+declare function ForeignKey(tableName: string, columnName: string, options?: {
+    type?: ColumnDataType;
+    name?: string;
+    onDelete?: string;
+    onUpdate?: string;
+    description?: string;
+    nullable?: boolean;
+    default?: any;
+}): (target: any, propertyKey: string) => void;
+declare class BaseModel {
+    private _client?;
+    private _extra;
+    constructor(data?: Record<string, any>);
+    protected static getTableName(): string;
+    static getDescription(): string;
+    protected static getIndexes(): Index[];
+    protected static getFields(): Record<string, Field>;
+    protected static getPrimaryKeyName(): string;
+    protected static getAssociations(): ForeignKeyField[];
+    protected getFields(): Record<string, Field>;
+    protected getTableName(): string;
+    protected getPrimaryKeyName(): string;
+    protected getPrimaryKey(): Field | undefined;
+    protected get client(): SyntropixClient;
+    static createTable(_client?: SyntropixClient | null): Promise<TableCreateResponse>;
+    static dropTable(_client?: SyntropixClient | null): Promise<any>;
+    static renameTable(newName: string, _client?: SyntropixClient | null): Promise<any>;
+    static truncateTable(_client?: SyntropixClient | null): Promise<any>;
+    static create<T extends BaseModel>(this: new (data?: any) => T, data: Record<string, any>, _client?: SyntropixClient | null): Promise<any>;
+    save(_client?: SyntropixClient | null): Promise<any>;
+    remove(filter?: Filter, _client?: SyntropixClient | null): Promise<number>;
+    static bulkCreate<T extends BaseModel>(this: new (data?: any) => T, datas: Record<string, any>[], batchSize?: number, _client?: SyntropixClient | null): Promise<number>;
+    static update<T extends BaseModel>(this: new (data?: any) => T, filter: Filter, data: Record<string, any>, _client?: SyntropixClient | null): Promise<number>;
+    static delete<T extends BaseModel>(this: new (data?: any) => T, filter: Filter, _client?: SyntropixClient | null): Promise<number>;
+    static get<T extends BaseModel>(this: new (data?: any) => T, filter: Filter, select?: string[], _client?: SyntropixClient | null): Promise<T>;
+    static filter<T extends BaseModel>(this: new (data?: any) => T, options: {
+        filter: Filter;
+        sort?: Sort[];
+        aggregate?: Aggregate[];
+        join?: Join;
+        limit?: number;
+        offset?: number;
+        groupBy?: GroupBy;
+        select?: string[];
+        _client?: SyntropixClient | null;
+    }): Promise<T[]>;
+    static count<T extends BaseModel>(this: new (data?: any) => T, options?: {
+        filter?: Filter;
+        join?: Join;
+        groupBy?: GroupBy;
+        _client?: SyntropixClient | null;
+    }): Promise<number>;
+    toString(): string;
+    toJSON(): Record<string, any>;
+}
+
+export { AND, type Aggregate, AggregateFunction, ArrayField, BETWEEN, BaseModel, BooleanField, CONTAINS, COSINE_DISTANCE, Client, ClientConfig, Column, ColumnDataType, DateField, DateTimeField, DecimalField, type DeleteData, type DeleteDataPayload, DoubleField, EQ, EQ_COL, EUCLIDEAN_DISTANCE, EnumField, Field, type Filter, type FilterGroup, type FilterItem, FilterOperation, FilterWrapper, ForeignKey, ForeignKeyAction, ForeignKeyField, GT, GTE, GTE_COL, GT_COL, type GroupBy, IN, IS_NOT_NULL, IS_NULL, I_LIKE, type Index, type Insert, type InsertData, IntegerField, type Join, JsonField, LIKE, LT, LTE, LTE_COL, LT_COL, MoneyField, NE, NEGATIVE_INNER_PRODUCT, NE_COL, NOT_IN, NOT_I_LIKE, NOT_LIKE, OR, OVERLAP, type Query, type QueryPayload, SIMILARITY, SIMILARITY_DISTANCE, STRICT_WORD_SIMILARITY, STRICT_WORD_SIMILARITY_DISTANCE, type SimilarityOptions, type Sort, SortType, StringField, SyntropixClient, SyntropixDBAccessType, type SyntropixDBTable, type SyntropixDBTableListItem, type TableAddColumn, type TableCreate, type TableDrop, type TableDropColumn, type TableGetList, type TableGetSchema, type TableModifyColumn, type TableRename, type TableTruncate, TextField, TimestampField, type Update, type UpdatePayload, UuidField, Value, VectorField, WORD_SIMILARITY, WORD_SIMILARITY_DISTANCE };