@syntropix/database 0.1.0 → 0.1.1

package/dist/types/basemodel.js

@@ -1,416 +0,0 @@
-// BaseModel implementation with decorator support
-import 'reflect-metadata';
-import { ClientConfig } from '../core/config';
-import { SyntropixClient } from '../core/syntropix';
-import { AggregateFunction } from './common';
-import { ColumnType } from './data-type';
-import { Field, ForeignKeyField, IntegerField } from './field';
-import { AND, EQ, GTE, OR, Value } from './filter';
-// Metadata keys
-const FIELDS_KEY = Symbol('fields');
-const TABLE_NAME_KEY = Symbol('tableName');
-const DESCRIPTION_KEY = Symbol('description');
-const INDEXES_KEY = Symbol('indexes');
-// Column decorator
-export function Column(options = {}) {
-    return function (target, propertyKey) {
-        const fields = Reflect.getMetadata(FIELDS_KEY, target.constructor) || {};
-        const fieldName = options.name || propertyKey.toLowerCase();
-        const columnType = options.type || ColumnType.Text;
-        const field = new (class extends Field {
-            constructor() {
-                super(columnType, {
-                    name: fieldName,
-                    description: options.description,
-                    isPrimaryKey: options.primary,
-                    isNullable: options.nullable,
-                    autoIncrement: options.autoIncrement,
-                    default: options.default,
-                });
-            }
-        })();
-        fields[propertyKey] = field;
-        Reflect.defineMetadata(FIELDS_KEY, fields, target.constructor);
-    };
-}
-// Description decorator
-export function Description(description) {
-    return function (target) {
-        Reflect.defineMetadata(DESCRIPTION_KEY, description, target);
-    };
-}
-// ForeignKey decorator
-export function ForeignKey(tableName, columnName, options = {}) {
-    return function (target, propertyKey) {
-        const fields = Reflect.getMetadata(FIELDS_KEY, target.constructor) || {};
-        const field = new ForeignKeyField(options.type || ColumnType.Integer, tableName, columnName, {
-            onDelete: options.onDelete,
-            onUpdate: options.onUpdate,
-            description: options.description,
-            isNullable: options.nullable,
-            default: options.default,
-        });
-        field.name = options.name || propertyKey.toLowerCase();
-        fields[propertyKey] = field;
-        Reflect.defineMetadata(FIELDS_KEY, fields, target.constructor);
-    };
-}
-export class BaseModel {
-    _client;
-    _extra = {};
-    constructor(data = {}) {
-        const fields = this.getFields();
-        // Create a mapping from column names to property names
-        const columnToPropertyMap = {};
-        for (const [propertyName, field] of Object.entries(fields)) {
-            columnToPropertyMap[field.name] = propertyName;
-        }
-        for (const [key, value] of Object.entries(data)) {
-            // Check if key is a property name
-            if (key in fields) {
-                this[key] = value;
-            }
-            // Check if key is a column name
-            else if (key in columnToPropertyMap) {
-                this[columnToPropertyMap[key]] = value;
-            }
-            // Otherwise, store in _extra
-            else {
-                this._extra[key] = value;
-            }
-        }
-    }
-    // Static metadata getters
-    static getTableName() {
-        const tableName = Reflect.getMetadata(TABLE_NAME_KEY, this);
-        if (tableName)
-            return tableName;
-        // Check for static tableName property
-        if ('tableName' in this && typeof this.tableName === 'string') {
-            return this.tableName;
-        }
-        return this.name.toLowerCase();
-    }
-    static getDescription() {
-        const metadataDescription = Reflect.getMetadata(DESCRIPTION_KEY, this);
-        if (metadataDescription)
-            return metadataDescription;
-        // Check for static description property as fallback
-        if ('description' in this && typeof this.description === 'string') {
-            return this.description;
-        }
-        return '';
-    }
-    static getIndexes() {
-        return Reflect.getMetadata(INDEXES_KEY, this) || [];
-    }
-    static getFields() {
-        const fields = Reflect.getMetadata(FIELDS_KEY, this) || {};
-        // Check if there's a primary key
-        let hasPrimaryKey = false;
-        for (const field of Object.values(fields)) {
-            if (field.isPrimaryKey) {
-                hasPrimaryKey = true;
-                field.isNullable = false;
-                break;
-            }
-        }
-        // If no primary key, add default 'id' field
-        if (!hasPrimaryKey && !('id' in fields)) {
-            fields['id'] = new IntegerField({
-                isPrimaryKey: true,
-                isNullable: false,
-                autoIncrement: true,
-                description: 'Primary key',
-            });
-            fields['id'].name = 'id';
-        }
-        return fields;
-    }
-    static getPrimaryKeyName() {
-        const fields = this.getFields();
-        for (const [key, field] of Object.entries(fields)) {
-            if (field.isPrimaryKey) {
-                return field.name;
-            }
-        }
-        return 'id';
-    }
-    static getAssociations() {
-        const fields = this.getFields();
-        return Object.values(fields).filter((f) => f instanceof ForeignKeyField);
-    }
-    // Instance metadata getters
-    getFields() {
-        return this.constructor.getFields();
-    }
-    getTableName() {
-        return this.constructor.getTableName();
-    }
-    getPrimaryKeyName() {
-        return this.constructor.getPrimaryKeyName();
-    }
-    getPrimaryKey() {
-        const fields = this.getFields();
-        for (const field of Object.values(fields)) {
-            if (field.isPrimaryKey) {
-                return field;
-            }
-        }
-        return undefined;
-    }
-    // Client getter
-    get client() {
-        if (!this._client) {
-            this._client = new SyntropixClient(new ClientConfig());
-        }
-        return this._client;
-    }
-    // Table operations
-    static async createTable(_client) {
-        const fields = this.getFields();
-        const columns = Object.values(fields).map((f) => f.into());
-        const foreignKeys = this.getAssociations().map((f) => ({
-            fromTable: this.getTableName(),
-            fromColumn: f.name,
-            toTable: f.tableName,
-            toColumn: f.columnName,
-            onDelete: f.onDelete,
-            onUpdate: f.onUpdate,
-        }));
-        const indexes = this.getIndexes();
-        const client = _client || new SyntropixClient(new ClientConfig());
-        return client.table.createTable({
-            name: this.getTableName(),
-            description: this.getDescription() || 'No description',
-            columns,
-            foreignKeys: foreignKeys,
-            indexes,
-        });
-    }
-    static async dropTable(_client) {
-        const client = _client || new SyntropixClient(new ClientConfig());
-        return client.table.dropTable({ name: this.getTableName() });
-    }
-    static async renameTable(newName, _client) {
-        const client = _client || new SyntropixClient(new ClientConfig());
-        return client.table.renameTable({
-            name: this.getTableName(),
-            newName: newName,
-        });
-    }
-    static async truncateTable(_client) {
-        const client = _client || new SyntropixClient(new ClientConfig());
-        return client.table.truncateTable({ name: this.getTableName() });
-    }
-    // Data operations
-    static async create(data, _client) {
-        const model = this;
-        const fields = model.getFields();
-        const columns = [];
-        const values = [];
-        for (const [key, value] of Object.entries(data)) {
-            if (key in fields) {
-                columns.push(fields[key].name);
-                values.push(value);
-            }
-            else {
-                throw new Error(`Invalid field: ${key}`);
-            }
-        }
-        const client = _client || new SyntropixClient(new ClientConfig());
-        return client.data.insertOne({
-            tableName: model.getTableName(),
-            data: {
-                columns,
-                values: [values],
-            },
-        });
-    }
-    async save(_client) {
-        const pk = this.getPrimaryKey();
-        const pkValue = this[this.getPrimaryKeyName()];
-        const fields = this.getFields();
-        if (pkValue === null || pkValue === undefined) {
-            const data = {};
-            for (const [key, field] of Object.entries(fields)) {
-                data[key] = this[key];
-            }
-            return this.constructor.create(data, _client);
-        }
-        const columns = [];
-        const values = [];
-        for (const [key, field] of Object.entries(fields)) {
-            if (field.name !== pk?.name) {
-                columns.push(field.name);
-                values.push(this[key]);
-            }
-        }
-        return (_client ||
-            this.client.data.updateByPrimaryKey(pkValue, {
-                tableName: this.getTableName(),
-                payload: {
-                    filter: [[]],
-                    columns,
-                    values,
-                },
-            }));
-    }
-    async remove(filter, _client) {
-        const pk = this.getPrimaryKey();
-        const pkValue = this[this.getPrimaryKeyName()];
-        const finalFilter = filter || OR(AND(EQ(pk?.name || 'id', pkValue)));
-        return (_client ||
-            this.client.data.deleteData({
-                tableName: this.getTableName(),
-                payload: {
-                    filter: finalFilter,
-                },
-            }));
-    }
-    static async bulkCreate(datas, batchSize = 32, _client) {
-        if (!datas.length)
-            return 0;
-        if (batchSize <= 0)
-            throw new Error('Batch size must be greater than 0');
-        const model = this;
-        const fields = model.getFields();
-        let cnt = 0;
-        batchSize = Math.min(batchSize, 128);
-        const columns = Object.keys(datas[0]);
-        const columnsSet = new Set(columns);
-        for (const col of columns) {
-            if (!(col in fields)) {
-                throw new Error(`Invalid field: ${col}`);
-            }
-        }
-        let values = [];
-        const client = _client || new SyntropixClient(new ClientConfig());
-        for (const data of datas) {
-            if (columnsSet.size !== new Set(Object.keys(data)).size || !columns.every((c) => c in data)) {
-                throw new Error('All data must have the same columns');
-            }
-            values.push(columns.map((c) => data[c]));
-            if (values.length === batchSize) {
-                cnt += await client.data.insertData({
-                    tableName: model.getTableName(),
-                    data: { columns: columns.map((c) => fields[c].name), values },
-                });
-                values = [];
-            }
-        }
-        if (values.length > 0) {
-            cnt += await client.data.insertData({
-                tableName: model.getTableName(),
-                data: { columns: columns.map((c) => fields[c].name), values },
-            });
-        }
-        return cnt;
-    }
-    static async update(filter, data, _client) {
-        const model = this;
-        const fields = model.getFields();
-        const columns = Object.keys(data);
-        if (!columns.length) {
-            throw new Error('No columns to update');
-        }
-        for (const col of columns) {
-            if (!(col in fields)) {
-                throw new Error(`Invalid field: ${col}`);
-            }
-        }
-        const values = columns.map((c) => data[c]);
-        const client = _client || new SyntropixClient(new ClientConfig());
-        return client.data.updateData({
-            tableName: model.getTableName(),
-            payload: {
-                filter,
-                columns: columns.map((c) => fields[c].name),
-                values,
-            },
-        });
-    }
-    static async delete(filter, _client) {
-        const model = this;
-        const client = _client || new SyntropixClient(new ClientConfig());
-        return client.data.deleteData({
-            tableName: model.getTableName(),
-            payload: { filter },
-        });
-    }
-    static async get(filter, select, _client) {
-        const model = this;
-        const fields = model.getFields();
-        const client = _client || new SyntropixClient(new ClientConfig());
-        const data = await client.data.queryOne({
-            tableName: model.getTableName(),
-            query: {
-                filter,
-                select: select || Object.values(fields).map((f) => f.name),
-                limit: 1,
-            },
-        });
-        return new this(data);
-    }
-    static async filter(options) {
-        const model = this;
-        const client = options._client || new SyntropixClient(new ClientConfig());
-        const data = await client.data.queryMany({
-            tableName: model.getTableName(),
-            query: {
-                filter: options.filter,
-                sort: options.sort,
-                aggregate: options.aggregate,
-                join: options.join ? [options.join] : undefined,
-                limit: options.limit,
-                offset: options.offset,
-                groupBy: options.groupBy,
-                select: options.select,
-            },
-        });
-        return data.map((item) => new this(item));
-    }
-    static async count(options = {}) {
-        const model = this;
-        const client = options._client || new SyntropixClient(new ClientConfig());
-        const data = await client.data.queryMany({
-            tableName: model.getTableName(),
-            query: {
-                filter: options.filter || [[GTE('id', Value(0))]],
-                aggregate: [
-                    {
-                        column: 'id',
-                        function: AggregateFunction.Count,
-                        alias: 'count',
-                    },
-                ],
-                join: options.join ? [options.join] : undefined,
-                limit: 1,
-                offset: 0,
-                groupBy: options.groupBy,
-                select: ['count'],
-            },
-        });
-        return data.length > 0 ? data[0].count : 0;
-    }
-    toString() {
-        const fields = this.getFields();
-        const data = {};
-        for (const key of Object.keys(fields)) {
-            const value = this[key];
-            if (!(value instanceof Field)) {
-                data[key] = value;
-            }
-        }
-        data._extra = this._extra;
-        return `${this.constructor.name}(${JSON.stringify(data).slice(1, -1)})`;
-    }
-    toJSON() {
-        const fields = this.getFields();
-        const data = {};
-        for (const key of Object.keys(fields)) {
-            data[key] = this[key];
-        }
-        return { ...data, ...this._extra };
-    }
-}

package/dist/types/common.d.ts

@@ -1,75 +0,0 @@
-import { SortType } from './filter';
-import { SyntropixDBAccessType } from './requests';
-export declare enum ForeignKeyAction {
-    Cascade = "Cascade",
-    Restrict = "Restrict",
-    SetNull = "SetNull",
-    NoAction = "NoAction",
-    SetDefault = "SetDefault"
-}
-export declare enum AggregateFunction {
-    Count = "Count",
-    Sum = "Sum",
-    Avg = "Avg",
-    Min = "Min",
-    Max = "Max",
-    CountDistinct = "CountDistinct"
-}
-export interface Sort {
-    column: string;
-    direction: SortType;
-}
-export interface Join {
-    table: string;
-    on: any;
-}
-export interface Aggregate {
-    column: string;
-    function: AggregateFunction;
-    alias: string;
-}
-export interface GroupBy {
-    columns: string[];
-}
-export interface ForeignKey {
-    name?: string;
-    fromTable: string;
-    fromColumn: string;
-    toTable: string;
-    toColumn: string;
-    onDelete?: ForeignKeyAction;
-    onUpdate?: ForeignKeyAction;
-}
-export interface Column {
-    name: string;
-    columnType: string | Record<string, any>;
-    description?: string;
-    isPrimaryKey?: boolean;
-    isNullable?: boolean;
-    autoIncrement?: boolean;
-    default?: any;
-    defaultAccess?: SyntropixDBAccessType;
-}
-export interface Index {
-    name: string;
-    columns: string[];
-    unique?: boolean;
-}
-export interface SyntropixDBColumn {
-    id: string;
-    name: string;
-    description: string;
-    columnType: string | Record<string, any>;
-    isNullable: boolean;
-    isPrimaryKey: boolean;
-    autoIncrement: boolean;
-    default?: any;
-    defaultAccess?: SyntropixDBAccessType;
-}
-export interface SyntropixDBTable {
-    id: string;
-    name: string;
-    description: string;
-    createdAt: Date;
-    columns: SyntropixDBColumn[];
-}

package/dist/types/common.js

@@ -1,17 +0,0 @@
-export var ForeignKeyAction;
-(function (ForeignKeyAction) {
-    ForeignKeyAction["Cascade"] = "Cascade";
-    ForeignKeyAction["Restrict"] = "Restrict";
-    ForeignKeyAction["SetNull"] = "SetNull";
-    ForeignKeyAction["NoAction"] = "NoAction";
-    ForeignKeyAction["SetDefault"] = "SetDefault";
-})(ForeignKeyAction || (ForeignKeyAction = {}));
-export var AggregateFunction;
-(function (AggregateFunction) {
-    AggregateFunction["Count"] = "Count";
-    AggregateFunction["Sum"] = "Sum";
-    AggregateFunction["Avg"] = "Avg";
-    AggregateFunction["Min"] = "Min";
-    AggregateFunction["Max"] = "Max";
-    AggregateFunction["CountDistinct"] = "CountDistinct";
-})(AggregateFunction || (AggregateFunction = {}));

package/dist/types/data-type.d.ts

@@ -1,49 +0,0 @@
-interface StringType {
-    type: 'String';
-    maxLength: number;
-}
-interface VectorType {
-    type: 'Vector';
-    dimensions: number;
-}
-interface ArrayType {
-    type: 'Array';
-    dataType: string | Record<string, any>;
-}
-interface EnumType {
-    type: 'Enum';
-    name: string;
-    variants: string[];
-}
-interface MoneyType {
-    type: 'Money';
-    precision: number;
-    scale: number;
-}
-interface DecimalType {
-    type: 'Decimal';
-    precision: number;
-    scale: number;
-}
-export declare const ColumnType: {
-    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: string | Record<string, any>) => ArrayType;
-    readonly Enum: (name: string, variants: string[]) => EnumType;
-    readonly Money: (precision: number, scale: number) => MoneyType;
-    readonly Decimal: (precision: number, scale: number) => DecimalType;
-};
-type DataTypeMap = typeof ColumnType;
-type DataTypeValues = DataTypeMap[keyof DataTypeMap];
-type DataTypeReturnTypes = ReturnType<Extract<DataTypeValues, (...args: any[]) => any>>;
-export type ColumnType = Exclude<DataTypeValues, (...args: any[]) => any> | DataTypeReturnTypes;
-export {};

package/dist/types/data-type.js

@@ -1,19 +0,0 @@
-export const ColumnType = {
-    // Basic types
-    Integer: 'Integer',
-    String: (maxLength) => ({ type: 'String', maxLength }),
-    Text: 'Text',
-    Boolean: 'Boolean',
-    DateTime: 'DateTime',
-    Timestamp: 'Timestamp',
-    Date: 'Date',
-    Json: 'Json',
-    Uuid: 'Uuid',
-    Double: 'Double',
-    // Complex types
-    Vector: (dimensions) => ({ type: 'Vector', dimensions }),
-    Array: (dataType) => ({ type: 'Array', dataType }),
-    Enum: (name, variants) => ({ type: 'Enum', name, variants }),
-    Money: (precision, scale) => ({ type: 'Money', precision, scale }),
-    Decimal: (precision, scale) => ({ type: 'Decimal', precision, scale }),
-};

package/dist/types/dto/base.d.ts

@@ -1,4 +0,0 @@
-export interface ApiResponse<T> {
-    status: string;
-    data: T;
-}

package/dist/types/dto/base.js

@@ -1 +0,0 @@
-export {};

package/dist/types/dto/table.d.ts

@@ -1,22 +0,0 @@
-import { Column, ForeignKey, Index } from '../common';
-export interface TableCreateResponse {
-    _id: {
-        $oid: string;
-    };
-    table: {
-        id: string;
-        name: string;
-        description: string;
-        createdAt: any;
-        columns: Column[];
-        foreignKeys: ForeignKey[];
-        indexes: Index[];
-        schema: string;
-        defaultAccess: string | null;
-    };
-    createdAt: any;
-    updatedAt: any;
-    createdBy: string;
-    metadata: Record<string, any>;
-    triggers: any[];
-}

package/dist/types/dto/table.js

@@ -1 +0,0 @@
-export {};