@syntropix/database 0.0.5 → 0.0.6

package/dist/types/filter.js

@@ -1,8 +1,8 @@
 // Filter types for database queries
 export var SortType;
 (function (SortType) {
-    SortType["DESCENDING"] = "DESCENDING";
-    SortType["ASCENDING"] = "ASCENDING";
+    SortType["Descending"] = "Descending";
+    SortType["Ascending"] = "Ascending";
 })(SortType || (SortType = {}));
 export var FilterOperation;
 (function (FilterOperation) {
@@ -39,72 +39,72 @@ export const OR = (...conditions) => conditions;
 export const EQ = (field, value) => ({
     column: field,
     operator: FilterOperation.EQ,
-    static_value: value,
+    staticValue: value,
 });
 export const NE = (field, value) => ({
     column: field,
     operator: FilterOperation.NEQ,
-    static_value: value,
+    staticValue: value,
 });
 export const GT = (field, value) => ({
     column: field,
     operator: FilterOperation.GT,
-    static_value: value,
+    staticValue: value,
 });
 export const GTE = (field, value) => ({
     column: field,
     operator: FilterOperation.GTE,
-    static_value: value,
+    staticValue: value,
 });
 export const LT = (field, value) => ({
     column: field,
     operator: FilterOperation.LT,
-    static_value: value,
+    staticValue: value,
 });
 export const LTE = (field, value) => ({
     column: field,
     operator: FilterOperation.LTE,
-    static_value: value,
+    staticValue: value,
 });
 export const IN = (field, values) => ({
     column: field,
     operator: FilterOperation.In,
-    static_value: values,
+    staticValue: values,
 });
 export const CONTAINS = (field, value) => ({
     column: field,
     operator: FilterOperation.Contains,
-    static_value: value,
+    staticValue: value,
 });
 export const OVERLAP = (field, value) => ({
     column: field,
     operator: FilterOperation.Overlap,
-    static_value: value,
+    staticValue: value,
 });
 export const I_LIKE = (field, pattern) => ({
     column: field,
     operator: FilterOperation.ILike,
-    static_value: pattern,
+    staticValue: pattern,
 });
 export const NOT_I_LIKE = (field, pattern) => ({
     column: field,
     operator: FilterOperation.NotILike,
-    static_value: pattern,
+    staticValue: pattern,
 });
 export const NOT_IN = (field, values) => ({
     column: field,
     operator: FilterOperation.NotIn,
-    static_value: values,
+    staticValue: values,
 });
 export const LIKE = (field, pattern) => ({
     column: field,
     operator: FilterOperation.Like,
-    static_value: pattern,
+    staticValue: pattern,
 });
 export const NOT_LIKE = (field, pattern) => ({
     column: field,
     operator: FilterOperation.NotLike,
-    static_value: pattern,
+    staticValue: pattern,
 });
 export const IS_NULL = (field) => ({
     column: field,
@@ -117,93 +117,108 @@ export const IS_NOT_NULL = (field) => ({
 export const BETWEEN = (field, min, max) => ({
     column: field,
     operator: FilterOperation.Between,
-    static_value: [min, max],
+    staticValue: [min, max],
 });
 // Column comparison (compare two columns)
 export const EQ_COL = (field, otherField) => ({
     column: field,
     operator: FilterOperation.EQ,
-    column_value: otherField,
+    columnValue: otherField,
 });
 export const NE_COL = (field, otherField) => ({
     column: field,
     operator: FilterOperation.NEQ,
-    column_value: otherField,
+    columnValue: otherField,
 });
 export const GT_COL = (field, otherField) => ({
     column: field,
     operator: FilterOperation.GT,
-    column_value: otherField,
+    columnValue: otherField,
 });
 export const GTE_COL = (field, otherField) => ({
     column: field,
     operator: FilterOperation.GTE,
-    column_value: otherField,
+    columnValue: otherField,
 });
 export const LT_COL = (field, otherField) => ({
     column: field,
     operator: FilterOperation.LT,
-    column_value: otherField,
+    columnValue: otherField,
 });
 export const LTE_COL = (field, otherField) => ({
     column: field,
     operator: FilterOperation.LTE,
-    column_value: otherField,
+    columnValue: otherField,
 });
 // Similarity operations
 export const SIMILARITY = (field, value, options) => ({
     column: field,
     operator: FilterOperation.Similarity,
-    static_value: value,
-    similarity_options: options,
+    staticValue: value,
+    simiarityOptions: options,
 });
 export const SIMILARITY_DISTANCE = (field, value, options) => ({
     column: field,
     operator: FilterOperation.SimilarityDistance,
-    static_value: value,
-    similarity_options: options,
+    staticValue: value,
+    simiarityOptions: options,
 });
 export const WORD_SIMILARITY = (field, value, options) => ({
     column: field,
     operator: FilterOperation.WordSimilarity,
-    static_value: value,
-    similarity_options: options,
+    staticValue: value,
+    simiarityOptions: options,
 });
 export const WORD_SIMILARITY_DISTANCE = (field, value, options) => ({
     column: field,
     operator: FilterOperation.WordSimilarityDistance,
-    static_value: value,
-    similarity_options: options,
+    staticValue: value,
+    simiarityOptions: options,
 });
 export const STRICT_WORD_SIMILARITY = (field, value, options) => ({
     column: field,
     operator: FilterOperation.StrictWordSimilarity,
-    static_value: value,
-    similarity_options: options,
+    staticValue: value,
+    simiarityOptions: options,
 });
 export const STRICT_WORD_SIMILARITY_DISTANCE = (field, value, options) => ({
     column: field,
     operator: FilterOperation.StrictWordSimilarityDistance,
-    static_value: value,
-    similarity_options: options,
+    staticValue: value,
+    simiarityOptions: options,
 });
 export const EUCLIDEAN_DISTANCE = (field, value, options) => ({
     column: field,
     operator: FilterOperation.EuclideanDistance,
-    static_value: value,
-    similarity_options: options,
+    staticValue: value,
+    simiarityOptions: options,
 });
 export const NEGATIVE_INNER_PRODUCT = (field, value, options) => ({
     column: field,
     operator: FilterOperation.NegativeInnerProduct,
-    static_value: value,
-    similarity_options: options,
+    staticValue: value,
+    simiarityOptions: options,
 });
 export const COSINE_DISTANCE = (field, value, options) => ({
     column: field,
     operator: FilterOperation.CosineDistance,
-    static_value: value,
-    similarity_options: options,
+    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,43 +1,54 @@
 import { Aggregate, Column, ForeignKey, GroupBy, Index, Join, Sort } from './common';
-import { Filter } from './filter';
+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[];
-    foreign_keys: ForeignKey[];
+    foreignKeys: ForeignKey[];
     indexes: Index[];
+    defaultAccess?: SyntropixDBAccessType;
+    metadata?: Record<string, any>;
+    visible?: boolean;
+    path?: string;
 }
 export interface TableDrop {
     name: string;
 }
 export interface TableRename {
     name: string;
-    new_name: string;
+    newName: string;
 }
 export interface TableTruncate {
     name: string;
 }
 export interface TableAddColumn {
-    table_name: string;
+    tableName: string;
     column: Column;
 }
 export interface TableDropColumn {
-    table_name: string;
-    column_name: string;
+    tableName: string;
+    columnName: string;
 }
 export interface TableModifyColumn {
-    table_name: string;
+    tableName: string;
     column: Column;
 }
 export interface TableGetSchema {
-    table_name: string;
+    tableName: string;
 }
 export interface InsertData {
     columns: string[];
     values: any[][];
 }
 export interface Insert {
-    table_name: string;
+    tableName: string;
     data: InsertData;
 }
 export interface UpdatePayload {
@@ -46,27 +57,27 @@ export interface UpdatePayload {
     values: any[];
 }
 export interface Update {
-    table_name: string;
+    tableName: string;
     payload: UpdatePayload;
 }
 export interface DeleteDataPayload {
     filter: Filter;
 }
 export interface DeleteData {
-    table_name: string;
+    tableName: string;
     payload: DeleteDataPayload;
 }
 export interface QueryPayload {
-    filter?: Filter;
+    filter?: Filter | FilterGroup | FilterItem;
     sort?: Sort[];
     aggregate?: Aggregate[];
     join?: Join[];
     limit?: number;
     offset?: number;
-    group_by?: GroupBy;
+    groupBy?: GroupBy;
     select?: string[];
 }
 export interface Query {
-    table_name: string;
+    tableName: string;
     query: QueryPayload;
 }

package/dist/types/requests.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syntropix/database",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "type": "module",
   "description": "TypeScript SDK for database operations with ORM support",
   "main": "dist/index.js",