@syntropix/database 0.0.1 → 0.0.3

package/dist/types/field.js

@@ -1,16 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DoubleField = exports.DecimalField = exports.MoneyField = exports.EnumField = exports.ArrayField = exports.VectorField = exports.UuidField = exports.JsonField = exports.DateField = exports.TimestampField = exports.DateTimeField = exports.BooleanField = exports.IntegerField = exports.TextField = exports.StringField = exports.ForeignKeyField = exports.Field = void 0;
 // Field definitions for ORM
-const common_1 = require("./common");
-const data_type_1 = require("./data-type");
-class Field {
+import { ForeignKeyAction } from './common';
+import { DataType } from './data-type';
+export class Field {
+    name = '';
+    description = '';
+    column_type;
+    is_primary_key = false;
+    is_nullable = false;
+    auto_increment = false;
+    default;
     constructor(column_type, options = {}) {
-        this.name = '';
-        this.description = '';
-        this.is_primary_key = false;
-        this.is_nullable = false;
-        this.auto_increment = false;
         this.column_type = column_type;
         this.name = options.name?.toLowerCase() || '';
         this.description = options.description || '';
@@ -31,105 +30,91 @@ class Field {
         };
     }
 }
-exports.Field = Field;
-class ForeignKeyField extends Field {
+export class ForeignKeyField extends Field {
+    tableName;
+    columnName;
+    onDelete;
+    onUpdate;
     constructor(column_type, tableName, columnName, options = {}) {
         super(column_type, options);
         this.tableName = tableName;
         this.columnName = columnName;
-        this.onDelete = options.onDelete || common_1.ForeignKeyAction.CASCADE;
-        this.onUpdate = options.onUpdate || common_1.ForeignKeyAction.CASCADE;
+        this.onDelete = options.onDelete || ForeignKeyAction.CASCADE;
+        this.onUpdate = options.onUpdate || ForeignKeyAction.CASCADE;
     }
 }
-exports.ForeignKeyField = ForeignKeyField;
-class StringField extends Field {
+export class StringField extends Field {
     constructor(maxLength, options = {}) {
-        super(data_type_1.DataType.String(maxLength), options);
+        super(DataType.String(maxLength), options);
     }
 }
-exports.StringField = StringField;
-class TextField extends Field {
+export class TextField extends Field {
     constructor(options = {}) {
-        super(data_type_1.DataType.Text, options);
+        super(DataType.Text, options);
     }
 }
-exports.TextField = TextField;
-class IntegerField extends Field {
+export class IntegerField extends Field {
     constructor(options = {}) {
-        super(data_type_1.DataType.Integer, options);
+        super(DataType.Integer, options);
     }
 }
-exports.IntegerField = IntegerField;
-class BooleanField extends Field {
+export class BooleanField extends Field {
     constructor(options = {}) {
-        super(data_type_1.DataType.Boolean, options);
+        super(DataType.Boolean, options);
     }
 }
-exports.BooleanField = BooleanField;
-class DateTimeField extends Field {
+export class DateTimeField extends Field {
     constructor(options = {}) {
-        super(data_type_1.DataType.DateTime, options);
+        super(DataType.DateTime, options);
     }
 }
-exports.DateTimeField = DateTimeField;
-class TimestampField extends Field {
+export class TimestampField extends Field {
     constructor(options = {}) {
-        super(data_type_1.DataType.Timestamp, options);
+        super(DataType.Timestamp, options);
     }
 }
-exports.TimestampField = TimestampField;
-class DateField extends Field {
+export class DateField extends Field {
     constructor(options = {}) {
-        super(data_type_1.DataType.Date, options);
+        super(DataType.Date, options);
     }
 }
-exports.DateField = DateField;
-class JsonField extends Field {
+export class JsonField extends Field {
     constructor(options = {}) {
-        super(data_type_1.DataType.Json, options);
+        super(DataType.Json, options);
     }
 }
-exports.JsonField = JsonField;
-class UuidField extends Field {
+export class UuidField extends Field {
     constructor(options = {}) {
-        super(data_type_1.DataType.Uuid, options);
+        super(DataType.Uuid, options);
     }
 }
-exports.UuidField = UuidField;
-class VectorField extends Field {
+export class VectorField extends Field {
     constructor(dimensions, options = {}) {
-        super(data_type_1.DataType.Vector(dimensions), options);
+        super(DataType.Vector(dimensions), options);
     }
 }
-exports.VectorField = VectorField;
-class ArrayField extends Field {
+export class ArrayField extends Field {
     constructor(dataType, options = {}) {
-        super(data_type_1.DataType.Array(dataType), options);
+        super(DataType.Array(dataType), options);
     }
 }
-exports.ArrayField = ArrayField;
-class EnumField extends Field {
+export class EnumField extends Field {
     constructor(name, variants, options = {}) {
-        super(data_type_1.DataType.Enum(name, variants), options);
+        super(DataType.Enum(name, variants), options);
     }
 }
-exports.EnumField = EnumField;
-class MoneyField extends Field {
+export class MoneyField extends Field {
     constructor(precision, scale, options = {}) {
-        super(data_type_1.DataType.Money(precision, scale), options);
+        super(DataType.Money(precision, scale), options);
     }
 }
-exports.MoneyField = MoneyField;
-class DecimalField extends Field {
+export class DecimalField extends Field {
     constructor(precision, scale, options = {}) {
-        super(data_type_1.DataType.Decimal(precision, scale), options);
+        super(DataType.Decimal(precision, scale), options);
     }
 }
-exports.DecimalField = DecimalField;
-class DoubleField extends Field {
+export class DoubleField extends Field {
     constructor(options = {}) {
-        super(data_type_1.DataType.Double, options);
+        super(DataType.Double, options);
     }
 }
-exports.DoubleField = DoubleField;
-//# sourceMappingURL=field.js.map

package/dist/types/filter.d.ts

@@ -73,4 +73,3 @@ export declare const EUCLIDEAN_DISTANCE: (field: string, value: any, options: Si
 export declare const NEGATIVE_INNER_PRODUCT: (field: string, value: any, options: SimilarityOptions) => SyntropixDBFilterItem;
 export declare const COSINE_DISTANCE: (field: string, value: any, options: SimilarityOptions) => SyntropixDBFilterItem;
 export declare const Value: (value: any) => any;
-//# sourceMappingURL=filter.d.ts.map

package/dist/types/filter.js

@@ -1,13 +1,10 @@
-"use strict";
 // Filter types for database queries
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Value = exports.COSINE_DISTANCE = exports.NEGATIVE_INNER_PRODUCT = exports.EUCLIDEAN_DISTANCE = exports.STRICT_WORD_SIMILARITY_DISTANCE = exports.STRICT_WORD_SIMILARITY = exports.WORD_SIMILARITY_DISTANCE = exports.WORD_SIMILARITY = exports.SIMILARITY_DISTANCE = exports.SIMILARITY = exports.LTE_COL = exports.LT_COL = exports.GTE_COL = exports.GT_COL = exports.NE_COL = exports.EQ_COL = exports.BETWEEN = exports.IS_NOT_NULL = exports.IS_NULL = exports.NOT_LIKE = exports.LIKE = exports.NOT_IN = exports.IN = exports.LTE = exports.LT = exports.GTE = exports.GT = exports.NE = exports.EQ = exports.OR = exports.AND = exports.FilterOperation = exports.SortType = void 0;
-var SortType;
+export var SortType;
 (function (SortType) {
     SortType["DESCENDING"] = "DESCENDING";
     SortType["ASCENDING"] = "ASCENDING";
-})(SortType || (exports.SortType = SortType = {}));
-var FilterOperation;
+})(SortType || (SortType = {}));
+export var FilterOperation;
 (function (FilterOperation) {
     FilterOperation["LT"] = "LT";
     FilterOperation["LTE"] = "LTE";
@@ -31,190 +28,158 @@ var FilterOperation;
     FilterOperation["EuclideanDistance"] = "EuclideanDistance";
     FilterOperation["NegativeInnerProduct"] = "NegativeInnerProduct";
     FilterOperation["CosineDistance"] = "CosineDistance";
-})(FilterOperation || (exports.FilterOperation = FilterOperation = {}));
+})(FilterOperation || (FilterOperation = {}));
 // Filter builder functions
-const AND = (...conditions) => conditions;
-exports.AND = AND;
-const OR = (...conditions) => conditions;
-exports.OR = OR;
-const EQ = (field, value) => ({
+export const AND = (...conditions) => conditions;
+export const OR = (...conditions) => conditions;
+export const EQ = (field, value) => ({
     column: field,
     operator: FilterOperation.EQ,
     static_value: value,
 });
-exports.EQ = EQ;
-const NE = (field, value) => ({
+export const NE = (field, value) => ({
     column: field,
     operator: FilterOperation.NEQ,
     static_value: value,
 });
-exports.NE = NE;
-const GT = (field, value) => ({
+export const GT = (field, value) => ({
     column: field,
     operator: FilterOperation.GT,
     static_value: value,
 });
-exports.GT = GT;
-const GTE = (field, value) => ({
+export const GTE = (field, value) => ({
     column: field,
     operator: FilterOperation.GTE,
     static_value: value,
 });
-exports.GTE = GTE;
-const LT = (field, value) => ({
+export const LT = (field, value) => ({
     column: field,
     operator: FilterOperation.LT,
     static_value: value,
 });
-exports.LT = LT;
-const LTE = (field, value) => ({
+export const LTE = (field, value) => ({
     column: field,
     operator: FilterOperation.LTE,
     static_value: value,
 });
-exports.LTE = LTE;
-const IN = (field, values) => ({
+export const IN = (field, values) => ({
     column: field,
     operator: FilterOperation.In,
     static_value: values,
 });
-exports.IN = IN;
-const NOT_IN = (field, values) => ({
+export const NOT_IN = (field, values) => ({
     column: field,
     operator: FilterOperation.NotIn,
     static_value: values,
 });
-exports.NOT_IN = NOT_IN;
-const LIKE = (field, pattern) => ({
+export const LIKE = (field, pattern) => ({
     column: field,
     operator: FilterOperation.Like,
     static_value: pattern,
 });
-exports.LIKE = LIKE;
-const NOT_LIKE = (field, pattern) => ({
+export const NOT_LIKE = (field, pattern) => ({
     column: field,
     operator: FilterOperation.NotLike,
     static_value: pattern,
 });
-exports.NOT_LIKE = NOT_LIKE;
-const IS_NULL = (field) => ({
+export const IS_NULL = (field) => ({
     column: field,
     operator: FilterOperation.IsNull,
 });
-exports.IS_NULL = IS_NULL;
-const IS_NOT_NULL = (field) => ({
+export const IS_NOT_NULL = (field) => ({
     column: field,
     operator: FilterOperation.IsNotNull,
 });
-exports.IS_NOT_NULL = IS_NOT_NULL;
-const BETWEEN = (field, min, max) => ({
+export const BETWEEN = (field, min, max) => ({
     column: field,
     operator: FilterOperation.Between,
     static_value: [min, max],
 });
-exports.BETWEEN = BETWEEN;
 // Column comparison (compare two columns)
-const EQ_COL = (field, otherField) => ({
+export const EQ_COL = (field, otherField) => ({
     column: field,
     operator: FilterOperation.EQ,
     column_value: otherField,
 });
-exports.EQ_COL = EQ_COL;
-const NE_COL = (field, otherField) => ({
+export const NE_COL = (field, otherField) => ({
     column: field,
     operator: FilterOperation.NEQ,
     column_value: otherField,
 });
-exports.NE_COL = NE_COL;
-const GT_COL = (field, otherField) => ({
+export const GT_COL = (field, otherField) => ({
     column: field,
     operator: FilterOperation.GT,
     column_value: otherField,
 });
-exports.GT_COL = GT_COL;
-const GTE_COL = (field, otherField) => ({
+export const GTE_COL = (field, otherField) => ({
     column: field,
     operator: FilterOperation.GTE,
     column_value: otherField,
 });
-exports.GTE_COL = GTE_COL;
-const LT_COL = (field, otherField) => ({
+export const LT_COL = (field, otherField) => ({
     column: field,
     operator: FilterOperation.LT,
     column_value: otherField,
 });
-exports.LT_COL = LT_COL;
-const LTE_COL = (field, otherField) => ({
+export const LTE_COL = (field, otherField) => ({
     column: field,
     operator: FilterOperation.LTE,
     column_value: otherField,
 });
-exports.LTE_COL = LTE_COL;
 // Similarity operations
-const SIMILARITY = (field, value, options) => ({
+export const SIMILARITY = (field, value, options) => ({
     column: field,
     operator: FilterOperation.Similarity,
     static_value: value,
     similarity_options: options,
 });
-exports.SIMILARITY = SIMILARITY;
-const SIMILARITY_DISTANCE = (field, value, options) => ({
+export const SIMILARITY_DISTANCE = (field, value, options) => ({
     column: field,
     operator: FilterOperation.SimilarityDistance,
     static_value: value,
     similarity_options: options,
 });
-exports.SIMILARITY_DISTANCE = SIMILARITY_DISTANCE;
-const WORD_SIMILARITY = (field, value, options) => ({
+export const WORD_SIMILARITY = (field, value, options) => ({
     column: field,
     operator: FilterOperation.WordSimilarity,
     static_value: value,
     similarity_options: options,
 });
-exports.WORD_SIMILARITY = WORD_SIMILARITY;
-const WORD_SIMILARITY_DISTANCE = (field, value, options) => ({
+export const WORD_SIMILARITY_DISTANCE = (field, value, options) => ({
     column: field,
     operator: FilterOperation.WordSimilarityDistance,
     static_value: value,
     similarity_options: options,
 });
-exports.WORD_SIMILARITY_DISTANCE = WORD_SIMILARITY_DISTANCE;
-const STRICT_WORD_SIMILARITY = (field, value, options) => ({
+export const STRICT_WORD_SIMILARITY = (field, value, options) => ({
     column: field,
     operator: FilterOperation.StrictWordSimilarity,
     static_value: value,
     similarity_options: options,
 });
-exports.STRICT_WORD_SIMILARITY = STRICT_WORD_SIMILARITY;
-const STRICT_WORD_SIMILARITY_DISTANCE = (field, value, options) => ({
+export const STRICT_WORD_SIMILARITY_DISTANCE = (field, value, options) => ({
     column: field,
     operator: FilterOperation.StrictWordSimilarityDistance,
     static_value: value,
     similarity_options: options,
 });
-exports.STRICT_WORD_SIMILARITY_DISTANCE = STRICT_WORD_SIMILARITY_DISTANCE;
-const EUCLIDEAN_DISTANCE = (field, value, options) => ({
+export const EUCLIDEAN_DISTANCE = (field, value, options) => ({
     column: field,
     operator: FilterOperation.EuclideanDistance,
     static_value: value,
     similarity_options: options,
 });
-exports.EUCLIDEAN_DISTANCE = EUCLIDEAN_DISTANCE;
-const NEGATIVE_INNER_PRODUCT = (field, value, options) => ({
+export const NEGATIVE_INNER_PRODUCT = (field, value, options) => ({
     column: field,
     operator: FilterOperation.NegativeInnerProduct,
     static_value: value,
     similarity_options: options,
 });
-exports.NEGATIVE_INNER_PRODUCT = NEGATIVE_INNER_PRODUCT;
-const COSINE_DISTANCE = (field, value, options) => ({
+export const COSINE_DISTANCE = (field, value, options) => ({
     column: field,
     operator: FilterOperation.CosineDistance,
     static_value: value,
     similarity_options: options,
 });
-exports.COSINE_DISTANCE = COSINE_DISTANCE;
 // Helper function for values (backward compatibility)
-const Value = (value) => value;
-exports.Value = Value;
-//# sourceMappingURL=filter.js.map
+export const Value = (value) => value;

package/dist/types/requests.d.ts

@@ -109,4 +109,3 @@ export interface SyntropixDBUpdate {
 export interface SyntropixDBDelete {
     filter: SyntropixDBFilter;
 }
-//# sourceMappingURL=requests.d.ts.map

package/dist/types/requests.js

@@ -1,3 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=requests.js.map
+export {};

package/eslint.config.mjs

@@ -1,23 +1,23 @@
-import eslint from '@eslint/js';
-import { defineConfig, globalIgnores } from 'eslint/config';
-import tseslint from 'typescript-eslint';
-
-export default defineConfig([
-  globalIgnores(['dist/**', 'node_modules/**', 'examples/**']),
-  eslint.configs.recommended,
-  ...tseslint.configs.recommended,
-  {
-    files: ['**/*.ts', '**/*.tsx'],
-    languageOptions: {
-      parser: tseslint.parser,
-      parserOptions: {
-        project: './tsconfig.json',
-      },
-    },
-    rules: {
-      'no-unused-vars': 'off',
-      '@typescript-eslint/no-unused-vars': 'off',
-      '@typescript-eslint/no-explicit-any': 'off',
-    },
-  },
-]);
+import eslint from '@eslint/js';
+import { defineConfig, globalIgnores } from 'eslint/config';
+import tseslint from 'typescript-eslint';
+
+export default defineConfig([
+  globalIgnores(['dist/**', 'node_modules/**', 'examples/**', 'tests/**', 'jest.config.ts']),
+  eslint.configs.recommended,
+  ...tseslint.configs.recommended,
+  {
+    files: ['**/*.ts', '**/*.tsx'],
+    languageOptions: {
+      parser: tseslint.parser,
+      parserOptions: {
+        project: './tsconfig.json',
+      },
+    },
+    rules: {
+      'no-unused-vars': 'off',
+      '@typescript-eslint/no-unused-vars': 'off',
+      '@typescript-eslint/no-explicit-any': 'off',
+    },
+  },
+]);

package/examples/tsconfig.json

@@ -0,0 +1,13 @@
+// This file is used to let VSCode respect the tsconfig.json for this test folder
+{
+  "extends": "../tsconfig.json",
+  "include": [".", "../src"],
+  "compilerOptions": {
+    "noEmit": true,
+    "baseUrl": ".",
+    "paths": {
+      "@syntropix/database": ["../src/index.ts"],
+      "@syntropix/database/*": ["../src/*"]
+    }
+  }
+}

package/examples/usage.ts

@@ -1,73 +1,94 @@
-// Example usage of the BaseModel ORM
+import { AND, BaseModel, Column, EQ, IN, OR } from '@syntropix/database';
+import { DataClient } from '@syntropix/database/core/dataClient';
+import { TableClient } from '@syntropix/database/core/tableClient';
 import 'dotenv/config';
-import { BaseModel, Column } from '../dist/types/basemodel.js';
-import { AND, EQ, OR } from '../dist/types/filter.js';
 
-// User model extending Audited
-export class User extends BaseModel {
+class User extends BaseModel {
   static tableName = 'users';
 
-  @Column({ type: 'Integer', primary: true, auto_increment: true }) id!: number;
-  @Column() email!: string;
-  @Column({ name: 'full_name' }) fullName!: string;
-  @Column({ type: 'Json', nullable: true }) profile?: any;
-  @Column({ type: 'Boolean', name: 'is_active' }) isActive!: boolean;
+  @Column({ type: 'Integer', primary: true, auto_increment: true })
+  declare id: number;
+
+  @Column()
+  declare email: string;
+
+  @Column({ name: 'full_name' })
+  declare fullName: string;
+
+  @Column({ type: 'Json', nullable: true })
+  declare profile: any;
+
+  @Column({ type: 'Boolean', name: 'is_active' })
+  declare isActive: boolean;
 }
 
-// Example usage
-async function examples() {
+async function ORMExample() {
   // Create table
-  await User.createTable();
+  // await User.createTable();
 
   // Create a new user
-  const newUser = await User.create({
-    id: 1,
-    email: 'user@example.com',
-    fullName: 'John Doe',
-    isActive: true,
-  });
+  // const newUser = await User.create({
+  //   id: 1,
+  //   email: 'user@example.com',
+  //   fullName: 'John Doe',
+  //   isActive: true,
+  // });
+  // console.log(newUser);
 
-  // Get a user
-  const user = await User.get(OR(AND(EQ('email', 'user@example.com'))));
-  console.log(user);
+  // // Get a user
+  // const user = await User.get(OR(AND(EQ('email', 'user@example.com'))));
+  // console.log(user);
 
-  // Update user
-  user.fullName = 'Jane Doe1';
-  await user.save();
+  // // Update user
+  // user.fullName = 'Jane Doe1';
+  // await user.save();
 
-  // // Filter users
+  // Filter users
   const activeUsers = await User.filter({
-    filter: OR(AND(EQ('is_active', true))),
+    filter: OR(AND(IN('email', ['user@example.com', 'user3@example.com']))),
     limit: 10,
   });
 
-  // // Count users
-  const userCount = await User.count({
-    filter: OR(AND(EQ('is_active', true))),
-  });
   console.log(activeUsers);
-  console.log(userCount);
-  // // Delete user
-  await user.remove();
-
-  // // Bulk create
-  await User.bulkCreate([
-    {
-      id: 2,
-      email: 'user2@example.com',
-      fullName: 'User 2',
-      isActive: true,
-    },
-    {
-      id: 3,
-      email: 'user3@example.com',
-      fullName: 'User 3',
-      isActive: false,
-    },
-  ]);
 
-  // console.log('All operations completed successfully!');
+  // // // Count users
+  // const userCount = await User.count({
+  //   filter: OR(AND(EQ('is_active', true))),
+  // });
+  // console.log(activeUsers);
+  // console.log(userCount);
+  // // // Delete user
+  // await user.remove();
+
+  // // // Bulk create
+  // await User.bulkCreate([
+  //   {
+  //     id: 2,
+  //     email: 'user2@example.com',
+  //     fullName: 'User 2',
+  //     isActive: true,
+  //   },
+  //   {
+  //     id: 3,
+  //     email: 'user3@example.com',
+  //     fullName: 'User 3',
+  //     isActive: false,
+  //   },
+  // ]);
+}
+
+async function ClientExample() {
+  const tableClient = new TableClient();
+  const dataClient = new DataClient();
+  const data = await dataClient.queryMany({
+    table_name: 'users',
+    query: {
+      filter: OR(AND(EQ('is_active', true))),
+    },
+  });
+  console.log(data);
 }
 
 // Run examples
-examples().catch(console.error);
+ORMExample().catch(console.error);
+// ClientExample().catch(console.error);

package/jest.config.ts

@@ -0,0 +1,9 @@
+import type { Config } from 'jest';
+import { createDefaultEsmPreset, pathsToModuleNameMapper } from 'ts-jest';
+
+const presetConfig = createDefaultEsmPreset({});
+
+export default {
+  ...presetConfig,
+  moduleNameMapper: pathsToModuleNameMapper({ '@/*': ['src/*'] }, { prefix: '<rootDir>/' }),
+} satisfies Config;