@syntropix/database 0.0.5 → 0.1.0

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[];
 }

package/dist/types/field.d.ts

@@ -1,20 +1,23 @@
 import { Column, ForeignKeyAction } from './common';
 import { ColumnType } from './data-type';
+import { SyntropixDBAccessType } from './requests';
 export declare abstract class Field {
     name: string;
     description: string;
-    column_type: ColumnType;
-    is_primary_key: boolean;
-    is_nullable: boolean;
-    auto_increment: boolean;
+    columnType: ColumnType;
+    isPrimaryKey: boolean;
+    isNullable: boolean;
+    autoIncrement: boolean;
     default?: any;
+    defaultAccess?: SyntropixDBAccessType;
     constructor(column_type: ColumnType, options?: {
         name?: string;
         description?: string;
-        is_primary_key?: boolean;
-        is_nullable?: boolean;
-        auto_increment?: boolean;
+        isPrimaryKey?: boolean;
+        isNullable?: boolean;
+        autoIncrement?: boolean;
         default?: any;
+        defaultAccess?: SyntropixDBAccessType;
     });
     into(): Column;
 }
@@ -23,133 +26,149 @@ export declare class ForeignKeyField extends Field {
     columnName: string;
     onDelete: ForeignKeyAction;
     onUpdate: ForeignKeyAction;
-    constructor(column_type: ColumnType, tableName: string, columnName: string, options?: {
+    constructor(columnType: ColumnType, tableName: string, columnName: string, options?: {
         onDelete?: ForeignKeyAction;
         onUpdate?: ForeignKeyAction;
         description?: string;
-        is_primary_key?: boolean;
-        is_nullable?: boolean;
+        isPrimaryKey?: boolean;
+        isNullable?: boolean;
         default?: any;
+        defaultAccess?: SyntropixDBAccessType;
     });
 }
 export declare class StringField extends Field {
     constructor(maxLength: number, options?: {
         description?: string;
-        is_primary_key?: boolean;
-        is_nullable?: boolean;
+        isPrimaryKey?: boolean;
+        isNullable?: boolean;
         default?: string;
+        defaultAccess?: SyntropixDBAccessType;
     });
 }
 export declare class TextField extends Field {
     constructor(options?: {
         description?: string;
-        is_primary_key?: boolean;
-        is_nullable?: boolean;
+        isPrimaryKey?: boolean;
+        isNullable?: boolean;
         default?: string;
+        defaultAccess?: SyntropixDBAccessType;
     });
 }
 export declare class IntegerField extends Field {
     constructor(options?: {
         description?: string;
-        is_primary_key?: boolean;
-        is_nullable?: boolean;
-        auto_increment?: boolean;
+        isPrimaryKey?: boolean;
+        isNullable?: boolean;
+        autoIncrement?: boolean;
         default?: number;
+        defaultAccess?: SyntropixDBAccessType;
     });
 }
 export declare class BooleanField extends Field {
     constructor(options?: {
         description?: string;
-        is_primary_key?: boolean;
-        is_nullable?: boolean;
+        isPrimaryKey?: boolean;
+        isNullable?: boolean;
         default?: boolean;
+        defaultAccess?: SyntropixDBAccessType;
     });
 }
 export declare class DateTimeField extends Field {
     constructor(options?: {
         description?: string;
-        is_primary_key?: boolean;
-        is_nullable?: boolean;
+        isPrimaryKey?: boolean;
+        isNullable?: boolean;
         default?: Date;
+        defaultAccess?: SyntropixDBAccessType;
     });
 }
 export declare class TimestampField extends Field {
     constructor(options?: {
         description?: string;
-        is_primary_key?: boolean;
-        is_nullable?: boolean;
+        isPrimaryKey?: boolean;
+        isNullable?: boolean;
         default?: Date;
+        defaultAccess?: SyntropixDBAccessType;
     });
 }
 export declare class DateField extends Field {
     constructor(options?: {
         description?: string;
-        is_primary_key?: boolean;
-        is_nullable?: boolean;
+        isPrimaryKey?: boolean;
+        isNullable?: boolean;
         default?: Date;
+        defaultAccess?: SyntropixDBAccessType;
     });
 }
 export declare class JsonField extends Field {
     constructor(options?: {
         description?: string;
-        is_primary_key?: boolean;
-        is_nullable?: boolean;
+        isPrimaryKey?: boolean;
+        isNullable?: boolean;
         default?: Record<string, any>;
+        defaultAccess?: SyntropixDBAccessType;
     });
 }
 export declare class UuidField extends Field {
     constructor(options?: {
         description?: string;
-        is_primary_key?: boolean;
-        is_nullable?: boolean;
+        isPrimaryKey?: boolean;
+        isNullable?: boolean;
         default?: string;
+        defaultAccess?: SyntropixDBAccessType;
     });
 }
 export declare class VectorField extends Field {
     constructor(dimensions: number, options?: {
         description?: string;
-        is_primary_key?: boolean;
-        is_nullable?: boolean;
+        isPrimaryKey?: boolean;
+        isNullable?: boolean;
         default?: number[];
+        defaultAccess?: SyntropixDBAccessType;
     });
 }
 export declare class ArrayField extends Field {
     constructor(dataType: ColumnType, options?: {
         description?: string;
-        is_primary_key?: boolean;
-        is_nullable?: boolean;
+        isPrimaryKey?: boolean;
+        isNullable?: boolean;
         default?: any[];
+        defaultAccess?: SyntropixDBAccessType;
     });
 }
 export declare class EnumField extends Field {
     constructor(name: string, variants: string[], options?: {
         description?: string;
-        is_primary_key?: boolean;
-        is_nullable?: boolean;
+        isPrimaryKey?: boolean;
+        isNullable?: boolean;
         default?: string;
+        defaultAccess?: SyntropixDBAccessType;
     });
 }
 export declare class MoneyField extends Field {
     constructor(precision: number, scale: number, options?: {
         description?: string;
-        is_primary_key?: boolean;
-        is_nullable?: boolean;
+        isPrimaryKey?: boolean;
+        isNullable?: boolean;
         default?: number;
+        defaultAccess?: SyntropixDBAccessType;
     });
 }
 export declare class DecimalField extends Field {
     constructor(precision: number, scale: number, options?: {
         description?: string;
-        is_primary_key?: boolean;
-        is_nullable?: boolean;
+        isPrimaryKey?: boolean;
+        isNullable?: boolean;
         default?: number;
+        defaultAccess?: SyntropixDBAccessType;
     });
 }
 export declare class DoubleField extends Field {
     constructor(options?: {
         description?: string;
-        is_primary_key?: boolean;
-        is_nullable?: boolean;
+        isPrimaryKey?: boolean;
+        isNullable?: boolean;
         default?: number;
+        defaultAccess?: SyntropixDBAccessType;
     });
 }

package/dist/types/field.js

@@ -1,32 +1,35 @@
 // Field definitions for ORM
 import { ForeignKeyAction } from './common';
-import { DataType } from './data-type';
+import { ColumnType } from './data-type';
 export class Field {
     name = '';
     description = '';
-    column_type;
-    is_primary_key = false;
-    is_nullable = false;
-    auto_increment = false;
+    columnType;
+    isPrimaryKey = false;
+    isNullable = false;
+    autoIncrement = false;
     default;
+    defaultAccess;
     constructor(column_type, options = {}) {
-        this.column_type = column_type;
+        this.columnType = column_type;
         this.name = options.name?.toLowerCase() || '';
         this.description = options.description || '';
-        this.is_primary_key = options.is_primary_key || false;
-        this.is_nullable = options.is_nullable || false;
-        this.auto_increment = options.auto_increment || false;
+        this.isPrimaryKey = options.isPrimaryKey || false;
+        this.isNullable = options.isNullable || false;
+        this.autoIncrement = options.autoIncrement || false;
         this.default = options.default;
+        this.defaultAccess = options.defaultAccess;
     }
     into() {
         return {
             name: this.name,
-            column_type: this.column_type,
+            columnType: this.columnType,
             description: this.description,
-            is_primary_key: this.is_primary_key,
-            is_nullable: this.is_nullable,
-            auto_increment: this.auto_increment,
+            isPrimaryKey: this.isPrimaryKey,
+            isNullable: this.isNullable,
+            autoIncrement: this.autoIncrement,
             default: this.default,
+            defaultAccess: this.defaultAccess,
         };
     }
 }
@@ -35,86 +38,86 @@ export class ForeignKeyField extends Field {
     columnName;
     onDelete;
     onUpdate;
-    constructor(column_type, tableName, columnName, options = {}) {
-        super(column_type, options);
+    constructor(columnType, tableName, columnName, options = {}) {
+        super(columnType, options);
         this.tableName = tableName;
         this.columnName = columnName;
-        this.onDelete = options.onDelete || ForeignKeyAction.CASCADE;
-        this.onUpdate = options.onUpdate || ForeignKeyAction.CASCADE;
+        this.onDelete = options.onDelete || ForeignKeyAction.Cascade;
+        this.onUpdate = options.onUpdate || ForeignKeyAction.Cascade;
     }
 }
 export class StringField extends Field {
     constructor(maxLength, options = {}) {
-        super(DataType.String(maxLength), options);
+        super(ColumnType.String(maxLength), options);
     }
 }
 export class TextField extends Field {
     constructor(options = {}) {
-        super(DataType.Text, options);
+        super(ColumnType.Text, options);
     }
 }
 export class IntegerField extends Field {
     constructor(options = {}) {
-        super(DataType.Integer, options);
+        super(ColumnType.Integer, options);
     }
 }
 export class BooleanField extends Field {
     constructor(options = {}) {
-        super(DataType.Boolean, options);
+        super(ColumnType.Boolean, options);
     }
 }
 export class DateTimeField extends Field {
     constructor(options = {}) {
-        super(DataType.DateTime, options);
+        super(ColumnType.DateTime, options);
     }
 }
 export class TimestampField extends Field {
     constructor(options = {}) {
-        super(DataType.Timestamp, options);
+        super(ColumnType.Timestamp, options);
     }
 }
 export class DateField extends Field {
     constructor(options = {}) {
-        super(DataType.Date, options);
+        super(ColumnType.Date, options);
     }
 }
 export class JsonField extends Field {
     constructor(options = {}) {
-        super(DataType.Json, options);
+        super(ColumnType.Json, options);
     }
 }
 export class UuidField extends Field {
     constructor(options = {}) {
-        super(DataType.Uuid, options);
+        super(ColumnType.Uuid, options);
     }
 }
 export class VectorField extends Field {
     constructor(dimensions, options = {}) {
-        super(DataType.Vector(dimensions), options);
+        super(ColumnType.Vector(dimensions), options);
     }
 }
 export class ArrayField extends Field {
     constructor(dataType, options = {}) {
-        super(DataType.Array(dataType), options);
+        super(ColumnType.Array(dataType), options);
     }
 }
 export class EnumField extends Field {
     constructor(name, variants, options = {}) {
-        super(DataType.Enum(name, variants), options);
+        super(ColumnType.Enum(name, variants), options);
     }
 }
 export class MoneyField extends Field {
     constructor(precision, scale, options = {}) {
-        super(DataType.Money(precision, scale), options);
+        super(ColumnType.Money(precision, scale), options);
     }
 }
 export class DecimalField extends Field {
     constructor(precision, scale, options = {}) {
-        super(DataType.Decimal(precision, scale), options);
+        super(ColumnType.Decimal(precision, scale), options);
     }
 }
 export class DoubleField extends Field {
     constructor(options = {}) {
-        super(DataType.Double, options);
+        super(ColumnType.Double, options);
     }
 }