@syntropix/database 0.0.4 → 0.0.6

package/dist/core/dataClient.js

@@ -1,3 +1,4 @@
+import { FilterWrapper } from '../types/filter';
 import { Client } from './client';
 import { ClientConfig } from './config';
 export class DataClient {
@@ -27,6 +28,7 @@ export class DataClient {
         throw new Error(response.message);
     }
     async queryOne(data, model) {
+        data.query.filter = FilterWrapper(data.query.filter);
         const response = await this.client.post('/query', { One: data });
         if (response.status === 'success') {
             const responseData = response.data;
@@ -38,6 +40,7 @@ export class DataClient {
         throw new Error(response.message);
     }
     async queryMany(data, model) {
+        data.query.filter = FilterWrapper(data.query.filter);
         const response = await this.client.post('/query', { Many: data });
         if (response.status === 'success') {
             const responseData = response.data;

package/dist/core/syntropix.d.ts

@@ -5,7 +5,7 @@ export declare class SyntropixClient {
     private config;
     private _tableClient?;
     private _dataClient?;
-    constructor(config: ClientConfig);
+    constructor(config?: ClientConfig);
     get table(): TableClient;
     get data(): DataClient;
 }

package/dist/core/syntropix.js

@@ -1,10 +1,11 @@
+import { ClientConfig } from './config';
 import { DataClient } from './dataClient';
 import { TableClient } from './tableClient';
 export class SyntropixClient {
     config;
     _tableClient;
     _dataClient;
-    constructor(config) {
+    constructor(config = new ClientConfig()) {
         this.config = config;
     }
     get table() {

package/dist/index.d.ts

@@ -3,7 +3,7 @@ export * from './core/config';
 export { SyntropixClient } from './core/syntropix';
 export { BaseModel, Column, ForeignKey } from './types/basemodel';
 export * from './types/common';
-export { DataType } from './types/data-type';
+export { ColumnType } from './types/data-type';
 export * from './types/field';
 export * from './types/filter';
 export * from './types/requests';

package/dist/index.js

@@ -4,7 +4,7 @@ export * from './core/config';
 export { SyntropixClient } from './core/syntropix';
 export { BaseModel, Column, ForeignKey } from './types/basemodel';
 export * from './types/common';
-export { DataType } from './types/data-type';
+export { ColumnType } from './types/data-type';
 export * from './types/field';
 export * from './types/filter';
 export * from './types/requests';

package/dist/types/basemodel.d.ts

@@ -1,21 +1,22 @@
 import 'reflect-metadata';
 import { SyntropixClient } from '../core/syntropix';
 import { Aggregate, GroupBy, Index, Join, Sort } from './common';
+import { ColumnType } from './data-type';
 import { TableCreateResponse } from './dto/table';
 import { Field, ForeignKeyField } from './field';
 import { Filter } from './filter';
 export declare function Column(options?: {
-    type?: string | Record<string, any>;
+    type?: ColumnType;
     name?: string;
     description?: string;
     primary?: boolean;
     nullable?: boolean;
-    auto_increment?: boolean;
+    autoIncrement?: boolean;
     default?: any;
 }): (target: any, propertyKey: string) => void;
 export declare function Description(description: string): (target: any) => void;
 export declare function ForeignKey(tableName: string, columnName: string, options?: {
-    type?: string | Record<string, any>;
+    type?: ColumnType;
     name?: string;
     onDelete?: string;
     onUpdate?: string;

package/dist/types/basemodel.js

@@ -3,6 +3,7 @@ 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
@@ -15,15 +16,15 @@ export function Column(options = {}) {
     return function (target, propertyKey) {
         const fields = Reflect.getMetadata(FIELDS_KEY, target.constructor) || {};
         const fieldName = options.name || propertyKey.toLowerCase();
-        const column_type = options.type || 'Text';
+        const columnType = options.type || ColumnType.Text;
         const field = new (class extends Field {
             constructor() {
-                super(column_type, {
+                super(columnType, {
                     name: fieldName,
                     description: options.description,
-                    is_primary_key: options.primary,
-                    is_nullable: options.nullable,
-                    auto_increment: options.auto_increment,
+                    isPrimaryKey: options.primary,
+                    isNullable: options.nullable,
+                    autoIncrement: options.autoIncrement,
                     default: options.default,
                 });
             }
@@ -42,11 +43,11 @@ export function Description(description) {
 export function ForeignKey(tableName, columnName, options = {}) {
     return function (target, propertyKey) {
         const fields = Reflect.getMetadata(FIELDS_KEY, target.constructor) || {};
-        const field = new ForeignKeyField(options.type || 'Integer', tableName, columnName, {
+        const field = new ForeignKeyField(options.type || ColumnType.Integer, tableName, columnName, {
             onDelete: options.onDelete,
             onUpdate: options.onUpdate,
             description: options.description,
-            is_nullable: options.nullable,
+            isNullable: options.nullable,
             default: options.default,
         });
         field.name = options.name || propertyKey.toLowerCase();
@@ -108,18 +109,18 @@ export class BaseModel {
         // Check if there's a primary key
         let hasPrimaryKey = false;
         for (const field of Object.values(fields)) {
-            if (field.is_primary_key) {
+            if (field.isPrimaryKey) {
                 hasPrimaryKey = true;
-                field.is_nullable = false;
+                field.isNullable = false;
                 break;
             }
         }
         // If no primary key, add default 'id' field
         if (!hasPrimaryKey && !('id' in fields)) {
             fields['id'] = new IntegerField({
-                is_primary_key: true,
-                is_nullable: false,
-                auto_increment: true,
+                isPrimaryKey: true,
+                isNullable: false,
+                autoIncrement: true,
                 description: 'Primary key',
             });
             fields['id'].name = 'id';
@@ -129,7 +130,7 @@ export class BaseModel {
     static getPrimaryKeyName() {
         const fields = this.getFields();
         for (const [key, field] of Object.entries(fields)) {
-            if (field.is_primary_key) {
+            if (field.isPrimaryKey) {
                 return field.name;
             }
         }
@@ -152,7 +153,7 @@ export class BaseModel {
     getPrimaryKey() {
         const fields = this.getFields();
         for (const field of Object.values(fields)) {
-            if (field.is_primary_key) {
+            if (field.isPrimaryKey) {
                 return field;
             }
         }
@@ -170,12 +171,12 @@ export class BaseModel {
         const fields = this.getFields();
         const columns = Object.values(fields).map((f) => f.into());
         const foreignKeys = this.getAssociations().map((f) => ({
-            from_table: this.getTableName(),
-            from_column: f.name,
-            to_table: f.tableName,
-            to_column: f.columnName,
-            on_delete: f.onDelete,
-            on_update: f.onUpdate,
+            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());
@@ -183,7 +184,7 @@ export class BaseModel {
             name: this.getTableName(),
             description: this.getDescription() || 'No description',
             columns,
-            foreign_keys: foreignKeys,
+            foreignKeys: foreignKeys,
             indexes,
         });
     }
@@ -195,7 +196,7 @@ export class BaseModel {
         const client = _client || new SyntropixClient(new ClientConfig());
         return client.table.renameTable({
             name: this.getTableName(),
-            new_name: newName,
+            newName: newName,
         });
     }
     static async truncateTable(_client) {
@@ -219,7 +220,7 @@ export class BaseModel {
         }
         const client = _client || new SyntropixClient(new ClientConfig());
         return client.data.insertOne({
-            table_name: model.getTableName(),
+            tableName: model.getTableName(),
             data: {
                 columns,
                 values: [values],
@@ -247,7 +248,7 @@ export class BaseModel {
         }
         return (_client ||
             this.client.data.updateByPrimaryKey(pkValue, {
-                table_name: this.getTableName(),
+                tableName: this.getTableName(),
                 payload: {
                     filter: [[]],
                     columns,
@@ -261,7 +262,7 @@ export class BaseModel {
         const finalFilter = filter || OR(AND(EQ(pk?.name || 'id', pkValue)));
         return (_client ||
             this.client.data.deleteData({
-                table_name: this.getTableName(),
+                tableName: this.getTableName(),
                 payload: {
                     filter: finalFilter,
                 },
@@ -292,7 +293,7 @@ export class BaseModel {
             values.push(columns.map((c) => data[c]));
             if (values.length === batchSize) {
                 cnt += await client.data.insertData({
-                    table_name: model.getTableName(),
+                    tableName: model.getTableName(),
                     data: { columns: columns.map((c) => fields[c].name), values },
                 });
                 values = [];
@@ -300,7 +301,7 @@ export class BaseModel {
         }
         if (values.length > 0) {
             cnt += await client.data.insertData({
-                table_name: model.getTableName(),
+                tableName: model.getTableName(),
                 data: { columns: columns.map((c) => fields[c].name), values },
             });
         }
@@ -321,7 +322,7 @@ export class BaseModel {
         const values = columns.map((c) => data[c]);
         const client = _client || new SyntropixClient(new ClientConfig());
         return client.data.updateData({
-            table_name: model.getTableName(),
+            tableName: model.getTableName(),
             payload: {
                 filter,
                 columns: columns.map((c) => fields[c].name),
@@ -333,7 +334,7 @@ export class BaseModel {
         const model = this;
         const client = _client || new SyntropixClient(new ClientConfig());
         return client.data.deleteData({
-            table_name: model.getTableName(),
+            tableName: model.getTableName(),
             payload: { filter },
         });
     }
@@ -342,7 +343,7 @@ export class BaseModel {
         const fields = model.getFields();
         const client = _client || new SyntropixClient(new ClientConfig());
         const data = await client.data.queryOne({
-            table_name: model.getTableName(),
+            tableName: model.getTableName(),
             query: {
                 filter,
                 select: select || Object.values(fields).map((f) => f.name),
@@ -355,7 +356,7 @@ export class BaseModel {
         const model = this;
         const client = options._client || new SyntropixClient(new ClientConfig());
         const data = await client.data.queryMany({
-            table_name: model.getTableName(),
+            tableName: model.getTableName(),
             query: {
                 filter: options.filter,
                 sort: options.sort,
@@ -363,7 +364,7 @@ export class BaseModel {
                 join: options.join ? [options.join] : undefined,
                 limit: options.limit,
                 offset: options.offset,
-                group_by: options.groupBy,
+                groupBy: options.groupBy,
                 select: options.select,
             },
         });
@@ -373,20 +374,20 @@ export class BaseModel {
         const model = this;
         const client = options._client || new SyntropixClient(new ClientConfig());
         const data = await client.data.queryMany({
-            table_name: model.getTableName(),
+            tableName: model.getTableName(),
             query: {
                 filter: options.filter || [[GTE('id', Value(0))]],
                 aggregate: [
                     {
                         column: 'id',
-                        function: AggregateFunction.COUNT,
+                        function: AggregateFunction.Count,
                         alias: 'count',
                     },
                 ],
                 join: options.join ? [options.join] : undefined,
                 limit: 1,
                 offset: 0,
-                group_by: options.groupBy,
+                groupBy: options.groupBy,
                 select: ['count'],
             },
         });

package/dist/types/common.d.ts

@@ -1,24 +1,25 @@
+import { SortType } from './filter';
+import { SyntropixDBAccessType } from './requests';
 export declare enum ForeignKeyAction {
-    CASCADE = "Cascade",
-    RESTRICT = "Restrict",
-    SET_NULL = "SetNull",
-    NO_ACTION = "NoAction",
-    SET_DEFAULT = "SetDefault"
+    Cascade = "Cascade",
+    Restrict = "Restrict",
+    SetNull = "SetNull",
+    NoAction = "NoAction",
+    SetDefault = "SetDefault"
 }
 export declare enum AggregateFunction {
-    COUNT = "Count",
-    SUM = "Sum",
-    AVG = "AVG",
-    MIN = "Min",
-    MAX = "Max",
-    COUNT_DISTINCT = "CountDistinct"
+    Count = "Count",
+    Sum = "Sum",
+    Avg = "Avg",
+    Min = "Min",
+    Max = "Max",
+    CountDistinct = "CountDistinct"
 }
 export interface Sort {
     column: string;
-    direction: 'ASCENDING' | 'DESCENDING';
+    direction: SortType;
 }
 export interface Join {
-    type: 'INNER' | 'LEFT' | 'RIGHT' | 'FULL';
     table: string;
     on: any;
 }
@@ -31,21 +32,23 @@ export interface GroupBy {
     columns: string[];
 }
 export interface ForeignKey {
-    from_table: string;
-    from_column: string;
-    to_table: string;
-    to_column: string;
-    on_delete?: ForeignKeyAction;
-    on_update?: ForeignKeyAction;
+    name?: string;
+    fromTable: string;
+    fromColumn: string;
+    toTable: string;
+    toColumn: string;
+    onDelete?: ForeignKeyAction;
+    onUpdate?: ForeignKeyAction;
 }
 export interface Column {
     name: string;
-    column_type: string | Record<string, any>;
+    columnType: string | Record<string, any>;
     description?: string;
-    is_primary_key?: boolean;
-    is_nullable?: boolean;
-    auto_increment?: boolean;
+    isPrimaryKey?: boolean;
+    isNullable?: boolean;
+    autoIncrement?: boolean;
     default?: any;
+    defaultAccess?: SyntropixDBAccessType;
 }
 export interface Index {
     name: string;
@@ -56,16 +59,17 @@ export interface SyntropixDBColumn {
     id: string;
     name: string;
     description: string;
-    column_type: string | Record<string, any>;
-    is_nullable: boolean;
-    is_primary_key: boolean;
-    auto_increment: boolean;
+    columnType: string | Record<string, any>;
+    isNullable: boolean;
+    isPrimaryKey: boolean;
+    autoIncrement: boolean;
     default?: any;
+    defaultAccess?: SyntropixDBAccessType;
 }
 export interface SyntropixDBTable {
     id: string;
     name: string;
     description: string;
-    created_at: Date;
+    createdAt: Date;
     columns: SyntropixDBColumn[];
 }

package/dist/types/common.js

@@ -1,18 +1,17 @@
-// Common types used across the SDK
 export var ForeignKeyAction;
 (function (ForeignKeyAction) {
-    ForeignKeyAction["CASCADE"] = "Cascade";
-    ForeignKeyAction["RESTRICT"] = "Restrict";
-    ForeignKeyAction["SET_NULL"] = "SetNull";
-    ForeignKeyAction["NO_ACTION"] = "NoAction";
-    ForeignKeyAction["SET_DEFAULT"] = "SetDefault";
+    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["COUNT_DISTINCT"] = "CountDistinct";
+    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,39 +1,49 @@
-export declare class DataType {
-    static readonly Integer = "Integer";
-    static readonly String: (maxLength: number) => {
-        type: string;
-        maxLength: number;
-    };
-    static readonly Text = "Text";
-    static readonly Boolean = "Boolean";
-    static readonly DateTime = "DateTime";
-    static readonly Timestamp = "Timestamp";
-    static readonly Date = "Date";
-    static readonly Json = "Json";
-    static readonly Uuid = "Uuid";
-    static readonly Double = "Double";
-    static readonly Vector: (dimensions: number) => {
-        type: string;
-        dimensions: number;
-    };
-    static readonly Array: (dataType: string | Record<string, any>) => {
-        type: string;
-        dataType: string | Record<string, any>;
-    };
-    static readonly Enum: (name: string, variants: string[]) => {
-        type: string;
-        name: string;
-        variants: string[];
-    };
-    static readonly Money: (precision: number, scale: number) => {
-        type: string;
-        precision: number;
-        scale: number;
-    };
-    static readonly Decimal: (precision: number, scale: number) => {
-        type: string;
-        precision: number;
-        scale: number;
-    };
+interface StringType {
+    type: 'String';
+    maxLength: number;
 }
-export type ColumnType = string | Record<string, any>;
+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,20 +1,19 @@
-// Data type definitions for database columns
-export class DataType {
+export const ColumnType = {
     // Basic types
-    static Integer = 'Integer';
-    static String = (maxLength) => ({ type: 'String', maxLength });
-    static Text = 'Text';
-    static Boolean = 'Boolean';
-    static DateTime = 'DateTime';
-    static Timestamp = 'Timestamp';
-    static Date = 'Date';
-    static Json = 'Json';
-    static Uuid = 'Uuid';
-    static Double = 'Double';
+    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
-    static Vector = (dimensions) => ({ type: 'Vector', dimensions });
-    static Array = (dataType) => ({ type: 'Array', dataType });
-    static Enum = (name, variants) => ({ type: 'Enum', name, variants });
-    static Money = (precision, scale) => ({ type: 'Money', precision, scale });
-    static Decimal = (precision, scale) => ({ type: 'Decimal', precision, scale });
-}
+    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/table.d.ts

@@ -7,16 +7,16 @@ export interface TableCreateResponse {
         id: string;
         name: string;
         description: string;
-        created_at: any;
+        createdAt: any;
         columns: Column[];
-        foreign_keys: ForeignKey[];
+        foreignKeys: ForeignKey[];
         indexes: Index[];
         schema: string;
-        default_access: string | null;
+        defaultAccess: string | null;
     };
-    created_at: any;
-    updated_at: any;
-    created_by: string;
+    createdAt: any;
+    updatedAt: any;
+    createdBy: string;
     metadata: Record<string, any>;
     triggers: any[];
 }