@syntropix/database 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -1,9 +1,582 @@
-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';
+import { ObjectId } from 'bson';
+
+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;
+}
+interface ArrayType {
+    Array: ArrayDataTypeSchema;
+}
+type ArrayDataTypeSchema = StringType | DecimalType | MoneyType | EnumType | 'Text' | 'Integer' | 'BigInteger' | 'Double' | 'DateTime' | 'Timestamp' | 'Date' | 'Boolean' | 'Uuid' | 'Json';
+type ColumnDataTypeSchema = StringType | VectorType | ArrayType | EnumType | MoneyType | DecimalType | 'Text' | 'Integer' | 'BigInteger' | 'Double' | 'DateTime' | 'Timestamp' | 'Date' | 'Boolean' | 'Uuid' | 'Json';
+
+declare const AccessType: {
+    readonly None: "None";
+    readonly Read: "Read";
+    readonly Write: "Write";
+    readonly Admin: "Admin";
+};
+type AccessType = (typeof AccessType)[keyof typeof AccessType];
+
+interface SyntropixDBColumn {
+    id: string;
+    name: string;
+    displayName: string;
+    description: string;
+    columnType: ColumnDataTypeSchema;
+    isPrimaryKey: boolean;
+    isNullable: boolean;
+    autoIncrement: boolean;
+    default: any | null;
+    defaultAccess: AccessType | null;
+}
+interface ColumnCreateOptions {
+    type?: ColumnDataTypeSchema;
+    name?: string;
+    displayName?: string;
+    description?: string;
+    primary?: boolean;
+    nullable?: boolean;
+    autoIncrement?: boolean;
+    default?: any;
+    defaultAccess?: AccessType;
+}
+
+interface Index {
+    name?: string;
+    columns: string[];
+    unique?: boolean;
+}
+
+declare const ForeignKeyAction: {
+    readonly Cascade: "Cascade";
+    readonly Restrict: "Restrict";
+    readonly SetNull: "SetNull";
+    readonly NoAction: "NoAction";
+    readonly SetDefault: "SetDefault";
+};
+type ForeignKeyAction = (typeof ForeignKeyAction)[keyof typeof ForeignKeyAction];
+interface SyntropixDBForeignKey {
+    name?: string;
+    fromTableName: string;
+    fromColumnName: string;
+    toTableName: string;
+    toColumnName: string;
+    onDelete?: ForeignKeyAction;
+    onUpdate?: ForeignKeyAction;
+}
+
+interface FieldOptions {
+    name?: string;
+    displayName?: string;
+    description?: string;
+    isPrimaryKey?: boolean;
+    isNullable?: boolean;
+    autoIncrement?: boolean;
+    default?: any;
+    defaultAccess?: AccessType;
+}
+interface ForeignKeyFieldOptions extends FieldOptions {
+    onDelete?: ForeignKeyAction;
+    onUpdate?: ForeignKeyAction;
+}
+
+declare const SortType: {
+    readonly Descending: "Descending";
+    readonly Ascending: "Ascending";
+};
+type SortType = (typeof SortType)[keyof typeof SortType];
+declare enum AggregateFunction {
+    Count = "Count",
+    Sum = "Sum",
+    Avg = "Avg",
+    Min = "Min",
+    Max = "Max",
+    CountDistinct = "CountDistinct"
+}
+interface Join {
+    table: string;
+    on: any;
+}
+interface Aggregate {
+    column: string;
+    function: AggregateFunction;
+    alias: string;
+}
+interface GroupBy {
+    columns: string[];
+}
+interface Sort {
+    column: string;
+    direction: SortType;
+}
+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 {
+    columnName: string;
+    operator: FilterOperation;
+    staticValue?: any;
+    columnValue?: string;
+    simiarityOptions?: SimilarityOptions;
+}
+type FilterGroup = FilterItem[];
+type Filter = FilterGroup[];
+
+interface SyntropixDBTable {
+    id: string;
+    name: string;
+    displayName: string;
+    description: string;
+    createdAt: Date;
+    schema: string;
+    defaultAccess: AccessType | null;
+    columns: SyntropixDBColumn[];
+    foreignKeys: SyntropixDBForeignKey[];
+    indexes: Index[];
+}
+interface SyntropixDBTableSchema {
+    id: string;
+    column_access: Record<string, AccessType>;
+    metadata: Record<string, any>;
+    path: string;
+    table: SyntropixDBTable;
+    visible: boolean;
+    table_access: AccessType;
+}
+interface SyntropixDBTableListItem {
+    id: string;
+    name: string;
+    description: string;
+    metadata: Record<string, any>;
+    path: string;
+    visible: boolean;
+    access: AccessType;
+}
+
+interface ColumnCreateDto {
+    name: string;
+    displayName?: string;
+    description: string;
+    columnType: ColumnDataTypeSchema;
+    isPrimaryKey: boolean;
+    isNullable: boolean;
+    autoIncrement: boolean;
+    default?: any;
+    defaultAccess?: AccessType;
+}
+
+interface TableCreateDto {
+    name: string;
+    displayName?: string;
+    description: string;
+    columns: ColumnCreateDto[];
+    foreignKeys: SyntropixDBForeignKey[];
+    indexes: Index[];
+    defaultAccess?: AccessType;
+    metadata?: Record<string, any>;
+    visible?: boolean;
+    path?: string;
+}
+interface TableGetSchemaDto {
+    tableName: string;
+}
+interface TableDropDto {
+    tableName: string;
+}
+interface TableRenameDto {
+    tableName: string;
+    newTableName: string;
+}
+interface TableTruncateDto {
+    tableName: string;
+}
+interface TableAddColumnDto {
+    tableName: string;
+    column: SyntropixDBColumn;
+}
+interface TableDropColumnDto {
+    tableName: string;
+    columnName: string;
+}
+interface TableModifyColumnDto {
+    tableName: string;
+    column: SyntropixDBColumn;
+}
+interface TableGetListDto {
+    search?: string;
+    path?: string;
+    page?: number;
+    pageSize?: number;
+}
+interface InsertDataDto {
+    columns: string[];
+    values: any[][];
+}
+interface InsertDto {
+    tableName: string;
+    data: InsertDataDto;
+}
+interface UpdatePayloadDto {
+    filter: Filter;
+    columns: string[];
+    values: any[];
+}
+interface UpdateDto {
+    tableName: string;
+    payload: UpdatePayloadDto;
+}
+interface DeleteDataPayloadDto {
+    filter: Filter;
+}
+interface DeleteDataDto {
+    tableName: string;
+    payload: DeleteDataPayloadDto;
+}
+interface QueryPayloadDto {
+    filter?: Filter | FilterGroup | FilterItem;
+    sort?: Sort[];
+    aggregate?: Aggregate[];
+    join?: Join[];
+    limit?: number;
+    offset?: number;
+    groupBy?: GroupBy;
+    select?: string[];
+}
+interface QueryDto {
+    tableName: string;
+    query: QueryPayloadDto;
+}
+
+interface ColumnCreateResponse {
+    id: string;
+    name: string;
+    displayName: string;
+    description: string;
+    columnType: ColumnDataTypeSchema;
+    isPrimaryKey: boolean;
+    isNullable: boolean;
+    autoIncrement: boolean;
+    default: any | null;
+    defaultAccess: AccessType | null;
+}
+
+interface SyntropixSuccessResponse<T> {
+    status: 'success';
+    data: T;
+}
+interface SyntropixErrorResponse {
+    status: 'error';
+    message: string;
+}
+type SyntropixResponse<T> = SyntropixSuccessResponse<T> | SyntropixErrorResponse;
+
+interface TableCreateResponse {
+    _id: ObjectId;
+    table: SyntropixDBTable;
+    createdAt: Date;
+    updatedAt: Date;
+    createdBy: string;
+    metadata: Record<string, any>;
+    path: string;
+    visible: boolean;
+}
+type TableSchemaResponse = SyntropixDBTableSchema;
+type TableListResponse = SyntropixDBTableListItem[];
+
+declare class ClientConfig {
+    apiKey?: string;
+    baseUrl?: string;
+    timeout?: number;
+    retries?: number;
+    constructor(config?: any);
+}
+
+declare class BaseClient {
+    protected config: ClientConfig;
+    constructor(config: ClientConfig);
+    private headers;
+    private url;
+    get<T>(path: string, data?: Record<string, any>): Promise<T>;
+    post<T>(path: string, data?: Record<string, any>): Promise<T>;
+}
+
+declare class DataClient {
+    private client;
+    constructor(config?: ClientConfig);
+    insertData(data: InsertDto): Promise<any>;
+    insertOne(data: InsertDto): Promise<any>;
+    updateByPrimaryKey(pk: string, data: UpdateDto): Promise<any>;
+    queryOne(data: QueryDto, model?: any): Promise<any>;
+    queryMany(data: QueryDto, model?: any): Promise<any>;
+    updateData(data: UpdateDto): Promise<any>;
+    deleteData(data: DeleteDataDto): Promise<any>;
+}
+
+declare class TableClient {
+    private client;
+    constructor(config?: ClientConfig);
+    createTable(data: TableCreateDto): Promise<TableCreateResponse>;
+    dropTable(data: TableDropDto): Promise<any>;
+    renameTable(data: TableRenameDto): Promise<any>;
+    truncateTable(data: TableTruncateDto): Promise<any>;
+    addColumn(data: TableAddColumnDto): Promise<any>;
+    dropColumn(data: TableDropColumnDto): Promise<any>;
+    modifyColumn(data: TableModifyColumnDto): Promise<any>;
+    getTableSchema(data: TableGetSchemaDto): Promise<TableSchemaResponse>;
+    getTableList(data: TableGetListDto): Promise<TableListResponse>;
+}
+
+declare class SyntropixClient {
+    private config;
+    private _tableClient?;
+    private _dataClient?;
+    constructor(config?: ClientConfig);
+    get table(): TableClient;
+    get data(): DataClient;
+}
+
+declare abstract class Field {
+    name: string;
+    displayName: string;
+    description: string;
+    columnType: ColumnDataTypeSchema;
+    isPrimaryKey: boolean;
+    isNullable: boolean;
+    autoIncrement: boolean;
+    default?: any;
+    defaultAccess?: AccessType;
+    constructor(columnType: ColumnDataTypeSchema, options?: FieldOptions);
+    intoColumnCreateDto(): ColumnCreateDto;
+}
+declare class ForeignKeyField extends Field {
+    tableName: string;
+    columnName: string;
+    onDelete: ForeignKeyAction;
+    onUpdate: ForeignKeyAction;
+    constructor(columnType: ColumnDataTypeSchema, tableName: string, columnName: string, options?: ForeignKeyFieldOptions);
+}
+declare class StringField extends Field {
+    constructor(maxLength: number, options?: FieldOptions);
+}
+declare class TextField extends Field {
+    constructor(options?: FieldOptions);
+}
+declare class IntegerField extends Field {
+    constructor(options?: FieldOptions);
+}
+declare class BooleanField extends Field {
+    constructor(options?: FieldOptions);
+}
+declare class DateTimeField extends Field {
+    constructor(options?: FieldOptions);
+}
+declare class TimestampField extends Field {
+    constructor(options?: FieldOptions);
+}
+declare class DateField extends Field {
+    constructor(options?: FieldOptions);
+}
+declare class JsonField extends Field {
+    constructor(options?: FieldOptions);
+}
+declare class UuidField extends Field {
+    constructor(options?: FieldOptions);
+}
+declare class VectorField extends Field {
+    constructor(dimensions: number, options?: FieldOptions);
+}
+declare class ArrayField extends Field {
+    constructor(dataType: ArrayDataTypeSchema, options?: FieldOptions);
+}
+declare class EnumField extends Field {
+    constructor(name: string, variants: string[], options?: FieldOptions);
+}
+declare class MoneyField extends Field {
+    constructor(precision: number, scale: number, options?: FieldOptions);
+}
+declare class DecimalField extends Field {
+    constructor(precision: number, scale: number, options?: FieldOptions);
+}
+declare class DoubleField extends Field {
+    constructor(options?: FieldOptions);
+}
+
+declare function Column(options?: ColumnCreateOptions): (target: any, propertyKey: string) => void;
+declare function Description(description: string): (target: any) => void;
+declare function ForeignKey(tableName: string, columnName: string, options?: {
+    type?: ColumnDataTypeSchema;
+    displayName?: string;
+    name?: string;
+    onDelete?: ForeignKeyAction;
+    onUpdate?: ForeignKeyAction;
+    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;
+    protected static getDisplayName(): 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 getDisplayName(): string;
+    protected getPrimaryKeyName(): string;
+    protected getPrimaryKey(): Field | undefined;
+    protected get client(): SyntropixClient;
+    static createTable(client?: SyntropixClient): Promise<TableCreateResponse>;
+    static dropTable(client?: SyntropixClient): Promise<any>;
+    static renameTable(newName: string, client?: SyntropixClient): Promise<any>;
+    static truncateTable(client?: SyntropixClient): Promise<any>;
+    static getTableSchema(client?: SyntropixClient): Promise<TableSchemaResponse>;
+    static create<T extends BaseModel>(this: new (data?: any) => T, data: Record<string, any>, client?: SyntropixClient): Promise<any>;
+    save(client?: SyntropixClient): 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>;
+}
+
+declare const ArrayDataType: {
+    readonly String: (maxLength: number) => StringType;
+    readonly Decimal: (precision: number, scale: number) => DecimalType;
+    readonly Text: "Text";
+    readonly Integer: "Integer";
+    readonly BigInteger: "BigInteger";
+    readonly Double: "Double";
+    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";
+};
+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: ArrayDataTypeSchema) => ArrayType;
+    readonly Enum: (name: string, variants: string[]) => EnumType;
+    readonly Money: (precision: number, scale: number) => MoneyType;
+    readonly Decimal: (precision: number, scale: number) => DecimalType;
+};
+
+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;
+
+export { AND, AccessType, type Aggregate, AggregateFunction, ArrayDataType, type ArrayDataTypeSchema, ArrayField, type ArrayType, BETWEEN, BaseClient, BaseModel, BooleanField, CONTAINS, COSINE_DISTANCE, ClientConfig, Column, type ColumnCreateDto, type ColumnCreateOptions, type ColumnCreateResponse, ColumnDataType, type ColumnDataTypeSchema, DataClient, DateField, DateTimeField, DecimalField, type DecimalType, type DeleteDataDto, type DeleteDataPayloadDto, Description, DoubleField, EQ, EQ_COL, EUCLIDEAN_DISTANCE, EnumField, type EnumType, Field, type FieldOptions, type Filter, type FilterGroup, type FilterItem, FilterOperation, FilterWrapper, ForeignKey, ForeignKeyAction, ForeignKeyField, type ForeignKeyFieldOptions, GT, GTE, GTE_COL, GT_COL, type GroupBy, IN, IS_NOT_NULL, IS_NULL, I_LIKE, type Index, type InsertDataDto, type InsertDto, IntegerField, type Join, JsonField, LIKE, LT, LTE, LTE_COL, LT_COL, MoneyField, type MoneyType, NE, NEGATIVE_INNER_PRODUCT, NE_COL, NOT_IN, NOT_I_LIKE, NOT_LIKE, OR, OVERLAP, type QueryDto, type QueryPayloadDto, SIMILARITY, SIMILARITY_DISTANCE, STRICT_WORD_SIMILARITY, STRICT_WORD_SIMILARITY_DISTANCE, type SimilarityOptions, type Sort, SortType, StringField, type StringType, SyntropixClient, type SyntropixDBColumn, type SyntropixDBForeignKey, type SyntropixDBTable, type SyntropixDBTableListItem, type SyntropixDBTableSchema, type SyntropixErrorResponse, type SyntropixResponse, type SyntropixSuccessResponse, type TableAddColumnDto, TableClient, type TableCreateDto, type TableCreateResponse, type TableDropColumnDto, type TableDropDto, type TableGetListDto, type TableGetSchemaDto, type TableListResponse, type TableModifyColumnDto, type TableRenameDto, type TableSchemaResponse, type TableTruncateDto, TextField, TimestampField, type UpdateDto, type UpdatePayloadDto, UuidField, Value, VectorField, type VectorType, WORD_SIMILARITY, WORD_SIMILARITY_DISTANCE };