@syntropix/database 0.0.6 → 0.1.1

package/dist/types/field.d.ts

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

package/dist/types/field.js

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

package/dist/types/filter.d.ts

@@ -1,82 +0,0 @@
-export declare enum SortType {
-    Descending = "Descending",
-    Ascending = "Ascending"
-}
-export interface SimilarityOptions {
-    threshold: number;
-    order?: SortType;
-    alias?: string;
-}
-export 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"
-}
-export interface FilterItem {
-    column: string;
-    operator: FilterOperation;
-    staticValue?: any;
-    columnValue?: string;
-    simiarityOptions?: SimilarityOptions;
-}
-export type FilterGroup = FilterItem[];
-export type Filter = FilterGroup[];
-export declare const AND: (...conditions: FilterItem[]) => FilterGroup;
-export declare const OR: (...conditions: FilterGroup[]) => Filter;
-export declare const EQ: (field: string, value: any) => FilterItem;
-export declare const NE: (field: string, value: any) => FilterItem;
-export declare const GT: (field: string, value: any) => FilterItem;
-export declare const GTE: (field: string, value: any) => FilterItem;
-export declare const LT: (field: string, value: any) => FilterItem;
-export declare const LTE: (field: string, value: any) => FilterItem;
-export declare const IN: (field: string, values: any[]) => FilterItem;
-export declare const CONTAINS: (field: string, value: any) => FilterItem;
-export declare const OVERLAP: (field: string, value: any) => FilterItem;
-export declare const I_LIKE: (field: string, pattern: string) => FilterItem;
-export declare const NOT_I_LIKE: (field: string, pattern: string) => FilterItem;
-export declare const NOT_IN: (field: string, values: any[]) => FilterItem;
-export declare const LIKE: (field: string, pattern: string) => FilterItem;
-export declare const NOT_LIKE: (field: string, pattern: string) => FilterItem;
-export declare const IS_NULL: (field: string) => FilterItem;
-export declare const IS_NOT_NULL: (field: string) => FilterItem;
-export declare const BETWEEN: (field: string, min: any, max: any) => FilterItem;
-export declare const EQ_COL: (field: string, otherField: string) => FilterItem;
-export declare const NE_COL: (field: string, otherField: string) => FilterItem;
-export declare const GT_COL: (field: string, otherField: string) => FilterItem;
-export declare const GTE_COL: (field: string, otherField: string) => FilterItem;
-export declare const LT_COL: (field: string, otherField: string) => FilterItem;
-export declare const LTE_COL: (field: string, otherField: string) => FilterItem;
-export declare const SIMILARITY: (field: string, value: any, options: SimilarityOptions) => FilterItem;
-export declare const SIMILARITY_DISTANCE: (field: string, value: any, options: SimilarityOptions) => FilterItem;
-export declare const WORD_SIMILARITY: (field: string, value: any, options: SimilarityOptions) => FilterItem;
-export declare const WORD_SIMILARITY_DISTANCE: (field: string, value: any, options: SimilarityOptions) => FilterItem;
-export declare const STRICT_WORD_SIMILARITY: (field: string, value: any, options: SimilarityOptions) => FilterItem;
-export declare const STRICT_WORD_SIMILARITY_DISTANCE: (field: string, value: any, options: SimilarityOptions) => FilterItem;
-export declare const EUCLIDEAN_DISTANCE: (field: string, value: any, options: SimilarityOptions) => FilterItem;
-export declare const NEGATIVE_INNER_PRODUCT: (field: string, value: any, options: SimilarityOptions) => FilterItem;
-export declare const COSINE_DISTANCE: (field: string, value: any, options: SimilarityOptions) => FilterItem;
-export declare const Value: (value: any) => any;
-export declare function FilterWrapper(filter: Filter | FilterGroup | FilterItem | undefined): Filter | undefined;

package/dist/types/filter.js

@@ -1,224 +0,0 @@
-// Filter types for database queries
-export var SortType;
-(function (SortType) {
-    SortType["Descending"] = "Descending";
-    SortType["Ascending"] = "Ascending";
-})(SortType || (SortType = {}));
-export var FilterOperation;
-(function (FilterOperation) {
-    FilterOperation["LT"] = "LT";
-    FilterOperation["LTE"] = "LTE";
-    FilterOperation["GT"] = "GT";
-    FilterOperation["GTE"] = "GTE";
-    FilterOperation["EQ"] = "EQ";
-    FilterOperation["NEQ"] = "NEQ";
-    FilterOperation["Between"] = "Between";
-    FilterOperation["In"] = "In";
-    FilterOperation["Contains"] = "Contains";
-    FilterOperation["Overlap"] = "Overlap";
-    FilterOperation["NotIn"] = "NotIn";
-    FilterOperation["Like"] = "Like";
-    FilterOperation["NotLike"] = "NotLike";
-    FilterOperation["ILike"] = "ILike";
-    FilterOperation["NotILike"] = "NotILike";
-    FilterOperation["IsNull"] = "IsNull";
-    FilterOperation["IsNotNull"] = "IsNotNull";
-    FilterOperation["Similarity"] = "Similarity";
-    FilterOperation["SimilarityDistance"] = "SimilarityDistance";
-    FilterOperation["WordSimilarity"] = "WordSimilarity";
-    FilterOperation["WordSimilarityDistance"] = "WordSimilarityDistance";
-    FilterOperation["StrictWordSimilarity"] = "StrictWordSimilarity";
-    FilterOperation["StrictWordSimilarityDistance"] = "StrictWordSimilarityDistance";
-    FilterOperation["EuclideanDistance"] = "EuclideanDistance";
-    FilterOperation["NegativeInnerProduct"] = "NegativeInnerProduct";
-    FilterOperation["CosineDistance"] = "CosineDistance";
-})(FilterOperation || (FilterOperation = {}));
-// Filter builder functions
-export const AND = (...conditions) => conditions;
-export const OR = (...conditions) => conditions;
-export const EQ = (field, value) => ({
-    column: field,
-    operator: FilterOperation.EQ,
-    staticValue: value,
-});
-export const NE = (field, value) => ({
-    column: field,
-    operator: FilterOperation.NEQ,
-    staticValue: value,
-});
-export const GT = (field, value) => ({
-    column: field,
-    operator: FilterOperation.GT,
-    staticValue: value,
-});
-export const GTE = (field, value) => ({
-    column: field,
-    operator: FilterOperation.GTE,
-    staticValue: value,
-});
-export const LT = (field, value) => ({
-    column: field,
-    operator: FilterOperation.LT,
-    staticValue: value,
-});
-export const LTE = (field, value) => ({
-    column: field,
-    operator: FilterOperation.LTE,
-    staticValue: value,
-});
-export const IN = (field, values) => ({
-    column: field,
-    operator: FilterOperation.In,
-    staticValue: values,
-});
-export const CONTAINS = (field, value) => ({
-    column: field,
-    operator: FilterOperation.Contains,
-    staticValue: value,
-});
-export const OVERLAP = (field, value) => ({
-    column: field,
-    operator: FilterOperation.Overlap,
-    staticValue: value,
-});
-export const I_LIKE = (field, pattern) => ({
-    column: field,
-    operator: FilterOperation.ILike,
-    staticValue: pattern,
-});
-export const NOT_I_LIKE = (field, pattern) => ({
-    column: field,
-    operator: FilterOperation.NotILike,
-    staticValue: pattern,
-});
-export const NOT_IN = (field, values) => ({
-    column: field,
-    operator: FilterOperation.NotIn,
-    staticValue: values,
-});
-export const LIKE = (field, pattern) => ({
-    column: field,
-    operator: FilterOperation.Like,
-    staticValue: pattern,
-});
-export const NOT_LIKE = (field, pattern) => ({
-    column: field,
-    operator: FilterOperation.NotLike,
-    staticValue: pattern,
-});
-export const IS_NULL = (field) => ({
-    column: field,
-    operator: FilterOperation.IsNull,
-});
-export const IS_NOT_NULL = (field) => ({
-    column: field,
-    operator: FilterOperation.IsNotNull,
-});
-export const BETWEEN = (field, min, max) => ({
-    column: field,
-    operator: FilterOperation.Between,
-    staticValue: [min, max],
-});
-// Column comparison (compare two columns)
-export const EQ_COL = (field, otherField) => ({
-    column: field,
-    operator: FilterOperation.EQ,
-    columnValue: otherField,
-});
-export const NE_COL = (field, otherField) => ({
-    column: field,
-    operator: FilterOperation.NEQ,
-    columnValue: otherField,
-});
-export const GT_COL = (field, otherField) => ({
-    column: field,
-    operator: FilterOperation.GT,
-    columnValue: otherField,
-});
-export const GTE_COL = (field, otherField) => ({
-    column: field,
-    operator: FilterOperation.GTE,
-    columnValue: otherField,
-});
-export const LT_COL = (field, otherField) => ({
-    column: field,
-    operator: FilterOperation.LT,
-    columnValue: otherField,
-});
-export const LTE_COL = (field, otherField) => ({
-    column: field,
-    operator: FilterOperation.LTE,
-    columnValue: otherField,
-});
-// Similarity operations
-export const SIMILARITY = (field, value, options) => ({
-    column: field,
-    operator: FilterOperation.Similarity,
-    staticValue: value,
-    simiarityOptions: options,
-});
-export const SIMILARITY_DISTANCE = (field, value, options) => ({
-    column: field,
-    operator: FilterOperation.SimilarityDistance,
-    staticValue: value,
-    simiarityOptions: options,
-});
-export const WORD_SIMILARITY = (field, value, options) => ({
-    column: field,
-    operator: FilterOperation.WordSimilarity,
-    staticValue: value,
-    simiarityOptions: options,
-});
-export const WORD_SIMILARITY_DISTANCE = (field, value, options) => ({
-    column: field,
-    operator: FilterOperation.WordSimilarityDistance,
-    staticValue: value,
-    simiarityOptions: options,
-});
-export const STRICT_WORD_SIMILARITY = (field, value, options) => ({
-    column: field,
-    operator: FilterOperation.StrictWordSimilarity,
-    staticValue: value,
-    simiarityOptions: options,
-});
-export const STRICT_WORD_SIMILARITY_DISTANCE = (field, value, options) => ({
-    column: field,
-    operator: FilterOperation.StrictWordSimilarityDistance,
-    staticValue: value,
-    simiarityOptions: options,
-});
-export const EUCLIDEAN_DISTANCE = (field, value, options) => ({
-    column: field,
-    operator: FilterOperation.EuclideanDistance,
-    staticValue: value,
-    simiarityOptions: options,
-});
-export const NEGATIVE_INNER_PRODUCT = (field, value, options) => ({
-    column: field,
-    operator: FilterOperation.NegativeInnerProduct,
-    staticValue: value,
-    simiarityOptions: options,
-});
-export const COSINE_DISTANCE = (field, value, options) => ({
-    column: field,
-    operator: FilterOperation.CosineDistance,
-    staticValue: value,
-    simiarityOptions: options,
-});
-// Helper function for values (backward compatibility)
-export const Value = (value) => value;
-// Helper function for wrapping filter
-export function FilterWrapper(filter) {
-    if (filter === undefined) {
-        return undefined;
-    }
-    if (!Array.isArray(filter)) {
-        return OR(AND(filter));
-    }
-    else if (!filter.every((item) => Array.isArray(item))) {
-        return OR(filter);
-    }
-    else {
-        return filter;
-    }
-}

package/dist/types/requests.d.ts

@@ -1,83 +0,0 @@
-import { Aggregate, Column, ForeignKey, GroupBy, Index, Join, Sort } from './common';
-import { Filter, FilterGroup, FilterItem } from './filter';
-export declare const SyntropixDBAccessType: {
-    readonly None: "None";
-    readonly Read: "Read";
-    readonly Write: "Write";
-    readonly Admin: "Admin";
-};
-export type SyntropixDBAccessType = (typeof SyntropixDBAccessType)[keyof typeof SyntropixDBAccessType];
-export interface TableCreate {
-    name: string;
-    description?: string;
-    columns: Column[];
-    foreignKeys: ForeignKey[];
-    indexes: Index[];
-    defaultAccess?: SyntropixDBAccessType;
-    metadata?: Record<string, any>;
-    visible?: boolean;
-    path?: string;
-}
-export interface TableDrop {
-    name: string;
-}
-export interface TableRename {
-    name: string;
-    newName: string;
-}
-export interface TableTruncate {
-    name: string;
-}
-export interface TableAddColumn {
-    tableName: string;
-    column: Column;
-}
-export interface TableDropColumn {
-    tableName: string;
-    columnName: string;
-}
-export interface TableModifyColumn {
-    tableName: string;
-    column: Column;
-}
-export interface TableGetSchema {
-    tableName: string;
-}
-export interface InsertData {
-    columns: string[];
-    values: any[][];
-}
-export interface Insert {
-    tableName: string;
-    data: InsertData;
-}
-export interface UpdatePayload {
-    filter: Filter;
-    columns: string[];
-    values: any[];
-}
-export interface Update {
-    tableName: string;
-    payload: UpdatePayload;
-}
-export interface DeleteDataPayload {
-    filter: Filter;
-}
-export interface DeleteData {
-    tableName: string;
-    payload: DeleteDataPayload;
-}
-export interface QueryPayload {
-    filter?: Filter | FilterGroup | FilterItem;
-    sort?: Sort[];
-    aggregate?: Aggregate[];
-    join?: Join[];
-    limit?: number;
-    offset?: number;
-    groupBy?: GroupBy;
-    select?: string[];
-}
-export interface Query {
-    tableName: string;
-    query: QueryPayload;
-}

package/dist/types/requests.js

@@ -1,6 +0,0 @@
-export const SyntropixDBAccessType = {
-    None: 'None',
-    Read: 'Read',
-    Write: 'Write',
-    Admin: 'Admin',
-};