@syntropix/database 0.0.1 → 0.0.3

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@syntropix/database",
-  "version": "0.0.1",
+  "version": "0.0.3",
+  "type": "module",
   "description": "TypeScript SDK for database operations with ORM support",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -12,9 +13,9 @@
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",
-    "test": "jest",
-    "example": "ts-node examples/usage.ts",
-    "advanced": "ts-node examples/advanced-usage.ts",
+    "test": "node --experimental-vm-modules $(yarn bin jest)",
+    "publish": "npm publish --access public",
+    "example": "tsx --tsconfig examples/tsconfig.json examples/usage.ts",
     "lint": "eslint",
     "lint:fix": "eslint --fix",
     "format": "prettier --write .",
@@ -26,7 +27,7 @@
     "typescript",
     "sdk"
   ],
-  "author": "Syntropix",
+  "author": "Syntropix, Inc.",
   "license": "MIT",
   "dependencies": {
     "dotenv": "^17.2.3",

package/src/core/dataClient.ts

@@ -5,7 +5,7 @@ import { ClientConfig } from './config';
 export class DataClient {
   private client: Client;
 
-  constructor(config: ClientConfig) {
+  constructor(config: ClientConfig = new ClientConfig()) {
     this.client = new Client(config);
   }
 
@@ -26,8 +26,6 @@ export class DataClient {
   }
 
   async updateByPrimaryKey(pk: string, data: Update): Promise<any> {
-    console.log(pk);
-    console.log(data);
     const response = await this.client.post(`/update/${pk}`, data);
     if (response.status === 'success') {
       return response.data;
@@ -40,9 +38,6 @@ export class DataClient {
     if (response.status === 'success') {
       const responseData = response.data;
       if (model !== undefined) {
-        // In TypeScript, we would typically use a validation library or manual validation
-        // For now, we'll return the data as-is, but in a real implementation you might want to use
-        // a library like class-validator or zod for validation
         return new model(responseData);
       }
       return responseData;

package/src/core/tableClient.ts

@@ -1,3 +1,4 @@
+import { TableCreateResponse } from '@/types/dto/table';
 import { SyntropixDBTable } from '../types/common';
 import {
   TableAddColumn,
@@ -15,11 +16,11 @@ import { ClientConfig } from './config';
 export class TableClient {
   private client: Client;
 
-  constructor(config: ClientConfig) {
+  constructor(config: ClientConfig = new ClientConfig()) {
     this.client = new Client(config);
   }
 
-  async createTable(data: TableCreate): Promise<any> {
+  async createTable(data: TableCreate): Promise<TableCreateResponse> {
     const response = await this.client.post('/table/create', data);
     if (response.status === 'success') {
       return response.data;

package/src/types/basemodel.ts

@@ -3,6 +3,7 @@ import 'reflect-metadata';
 import { ClientConfig } from '../core/config';
 import { SyntropixClient } from '../core/syntropix';
 import { Aggregate, AggregateFunction, ForeignKey, GroupBy, Index, Join, Sort } from './common';
+import { TableCreateResponse } from './dto/table';
 import { Field, ForeignKeyField, IntegerField } from './field';
 import { AND, EQ, Filter, GTE, OR, Value } from './filter';
 
@@ -218,7 +219,7 @@ export class BaseModel {
   }
 
   // Table operations
-  static async createTable(_client?: SyntropixClient | null): Promise<any> {
+  static async createTable(_client?: SyntropixClient | null): Promise<TableCreateResponse> {
     const fields = this.getFields();
     const columns = Object.values(fields).map((f) => f.into());
     const foreignKeys: ForeignKey[] = this.getAssociations().map((f) => ({
@@ -465,7 +466,7 @@ export class BaseModel {
     this: new (data?: any) => T,
     options: {
       filter: Filter;
-      sort?: Sort;
+      sort?: Sort[];
       aggregate?: Aggregate[];
       join?: Join;
       limit?: number;

package/src/types/common.ts

@@ -1,83 +1,83 @@
-// Common types used across the SDK
-
-export enum ForeignKeyAction {
-  CASCADE = 'Cascade',
-  RESTRICT = 'Restrict',
-  SET_NULL = 'SetNull',
-  NO_ACTION = 'NoAction',
-  SET_DEFAULT = 'SetDefault',
-}
-
-export enum AggregateFunction {
-  COUNT = 'Count',
-  SUM = 'Sum',
-  AVG = 'AVG',
-  MIN = 'Min',
-  MAX = 'Max',
-  COUNT_DISTINCT = 'CountDistinct',
-}
-
-export interface Sort {
-  column: string;
-  order: 'ASC' | 'DESC';
-}
-
-export interface Join {
-  type: 'INNER' | 'LEFT' | 'RIGHT' | 'FULL';
-  table: string;
-  on: any;
-}
-
-export interface Aggregate {
-  column: string;
-  function: AggregateFunction;
-  alias: string;
-}
-
-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;
-}
-
-export interface Column {
-  name: string;
-  column_type: string | Record<string, any>;
-  description?: string;
-  is_primary_key?: boolean;
-  is_nullable?: boolean;
-  auto_increment?: boolean;
-  default?: any;
-}
-
-export interface Index {
-  name: string;
-  columns: string[];
-  unique?: boolean;
-}
-
-export interface SyntropixDBColumn {
-  id: string; // UUID as string in TypeScript
-  name: string;
-  description: string;
-  column_type: string | Record<string, any>;
-  is_nullable: boolean;
-  is_primary_key: boolean;
-  auto_increment: boolean;
-  default?: any; // Optional field
-}
-
-export interface SyntropixDBTable {
-  id: string; // UUID as string in TypeScript
-  name: string;
-  description: string;
-  created_at: Date;
-  columns: SyntropixDBColumn[];
-}
+// Common types used across the SDK
+
+export enum ForeignKeyAction {
+  CASCADE = 'Cascade',
+  RESTRICT = 'Restrict',
+  SET_NULL = 'SetNull',
+  NO_ACTION = 'NoAction',
+  SET_DEFAULT = 'SetDefault',
+}
+
+export enum AggregateFunction {
+  COUNT = 'Count',
+  SUM = 'Sum',
+  AVG = 'AVG',
+  MIN = 'Min',
+  MAX = 'Max',
+  COUNT_DISTINCT = 'CountDistinct',
+}
+
+export interface Sort {
+  column: string;
+  direction: 'ASCENDING' | 'DESCENDING';
+}
+
+export interface Join {
+  type: 'INNER' | 'LEFT' | 'RIGHT' | 'FULL';
+  table: string;
+  on: any;
+}
+
+export interface Aggregate {
+  column: string;
+  function: AggregateFunction;
+  alias: string;
+}
+
+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;
+}
+
+export interface Column {
+  name: string;
+  column_type: string | Record<string, any>;
+  description?: string;
+  is_primary_key?: boolean;
+  is_nullable?: boolean;
+  auto_increment?: boolean;
+  default?: any;
+}
+
+export interface Index {
+  name: string;
+  columns: string[];
+  unique?: boolean;
+}
+
+export interface SyntropixDBColumn {
+  id: string; // UUID as string in TypeScript
+  name: string;
+  description: string;
+  column_type: string | Record<string, any>;
+  is_nullable: boolean;
+  is_primary_key: boolean;
+  auto_increment: boolean;
+  default?: any; // Optional field
+}
+
+export interface SyntropixDBTable {
+  id: string; // UUID as string in TypeScript
+  name: string;
+  description: string;
+  created_at: Date;
+  columns: SyntropixDBColumn[];
+}

package/src/types/dto/base.ts

@@ -0,0 +1,4 @@
+export interface ApiResponse<T> {
+  status: string;
+  data: T;
+}

package/src/types/dto/table.ts

@@ -0,0 +1,21 @@
+import { Column, ForeignKey, Index } from '../common';
+
+export interface TableCreateResponse {
+  _id: { $oid: string };
+  table: {
+    id: string;
+    name: string;
+    description: string;
+    created_at: any;
+    columns: Column[];
+    foreign_keys: ForeignKey[];
+    indexes: Index[];
+    schema: string;
+    default_access: string | null;
+  };
+  created_at: any;
+  updated_at: any;
+  created_by: string;
+  metadata: Record<string, any>;
+  triggers: any[];
+}

package/src/types/filter.ts

@@ -1,5 +1,4 @@
 // Filter types for database queries
-
 export enum SortType {
   DESCENDING = 'DESCENDING',
   ASCENDING = 'ASCENDING',
@@ -20,9 +19,13 @@ export enum FilterOperation {
   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',
@@ -99,6 +102,30 @@ export const IN = (field: string, values: any[]): SyntropixDBFilterItem => ({
   static_value: values,
 });
 
+export const CONTAINS = (field: string, value: any): SyntropixDBFilterItem => ({
+  column: field,
+  operator: FilterOperation.Contains,
+  static_value: value,
+});
+
+export const OVERLAP = (field: string, value: any): SyntropixDBFilterItem => ({
+  column: field,
+  operator: FilterOperation.Overlap,
+  static_value: value,
+});
+
+export const I_LIKE = (field: string, pattern: string): SyntropixDBFilterItem => ({
+  column: field,
+  operator: FilterOperation.ILike,
+  static_value: pattern,
+});
+
+export const NOT_I_LIKE = (field: string, pattern: string): SyntropixDBFilterItem => ({
+  column: field,
+  operator: FilterOperation.NotILike,
+  static_value: pattern,
+});
+
 export const NOT_IN = (field: string, values: any[]): SyntropixDBFilterItem => ({
   column: field,
   operator: FilterOperation.NotIn,

package/src/types/requests.ts

@@ -1,6 +1,6 @@
 // Request types for database operations
 import { Aggregate, Column, ForeignKey, GroupBy, Index, Join, Sort } from './common';
-import { Filter, SortType, SyntropixDBFilter } from './filter';
+import { Filter } from './filter';
 
 // Table operations
 export interface TableCreate {
@@ -76,7 +76,7 @@ export interface DeleteData {
 
 export interface QueryPayload {
   filter?: Filter;
-  sort?: Sort;
+  sort?: Sort[];
   aggregate?: Aggregate[];
   join?: Join[];
   limit?: number;
@@ -89,53 +89,3 @@ export interface Query {
   table_name: string;
   query: QueryPayload;
 }
-
-// Rust-compatible type definitions
-export interface SyntropixDBSortItem {
-  column: string;
-  direction: SortType;
-}
-
-export type SyntropixDBSort = SyntropixDBSortItem[];
-
-export interface SyntropixDBJoin {
-  table: string;
-  on: string;
-}
-
-export interface SyntropixDBAggregate {
-  function: string;
-  column: string;
-  alias: string;
-}
-
-export type SyntropixDBGroupBy = string[];
-
-export type SyntropixDBDistinct = string[];
-
-export interface SyntropixDBQuery {
-  filter: SyntropixDBFilter;
-  sort?: SyntropixDBSort;
-  limit?: number;
-  offset?: number;
-  select?: string[];
-  join?: SyntropixDBJoin[];
-  aggregate?: SyntropixDBAggregate[];
-  group_by?: SyntropixDBGroupBy;
-  distinct?: SyntropixDBDistinct;
-}
-
-export interface SyntropixDBInsert {
-  columns: string[];
-  values: any[][];
-}
-
-export interface SyntropixDBUpdate {
-  filter: SyntropixDBFilter;
-  columns: string[];
-  values: any[];
-}
-
-export interface SyntropixDBDelete {
-  filter: SyntropixDBFilter;
-}

package/tests/basic.test.ts

@@ -1,73 +1,141 @@
-// Example usage of the BaseModel ORM
+import { BaseModel, Column } from '@/types/basemodel';
+import { AND, EQ, OR } from '@/types/filter';
+
 import 'dotenv/config';
-import { BaseModel, Column } from '../src/types/basemodel.js';
-import { AND, EQ, OR } from '../src/types/filter.js';
-
-// User model extending Audited
-export 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;
+
+const getRandomString = () => {
+  return Math.random().toString(36).substring(2, 15);
+};
+
+class User extends BaseModel {
+  static tableName = `test_users_${getRandomString()}`;
+
+  @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() {
-  // Create table
-  await User.createTable();
-
-  // Create a new user
-  const newUser = await User.create({
-    id: 1,
-    email: 'user@example.com',
-    fullName: 'John Doe',
-    isActive: true,
+describe('BaseModel ORM', () => {
+  beforeAll(async () => {
+    await User.createTable();
   });
 
-  // Get a user
-  const user = await User.get(OR(AND(EQ('email', 'user@example.com'))));
-  console.log(user);
+  describe('User CRUD Operations', () => {
+    let userId: number;
+    let userEmail: string;
+    let userFullName: string;
+
+    test('should create a user', async () => {
+      const randomValue = getRandomString();
+      userEmail = `user${randomValue}@example.com`;
+      userFullName = `User ${randomValue}`;
+      const userCreateResp = await User.create({
+        email: userEmail,
+        fullName: userFullName,
+        isActive: true,
+      });
+
+      expect(userCreateResp).toBeDefined();
+      expect(userCreateResp.pk).toBeDefined();
+      userId = userCreateResp.pk;
+    });
+
+    test('should retrieve the created user by id', async () => {
+      const user = await User.get(OR(AND(EQ('id', userId))));
+      expect(user).toBeDefined();
+      expect(user.email).toBe(userEmail);
+      expect(user.fullName).toBe(userFullName);
+      expect(user.isActive).toBe(true);
+      expect(user.profile).toBeNull();
+    });
+
+    test('should update a user', async () => {
+      const user = await User.get(OR(AND(EQ('id', userId))));
+      userFullName = `User ${getRandomString()}`;
+      user.fullName = userFullName;
+      await user.save();
 
-  // Update user
-  user.fullName = 'Jane Doe1';
-  await user.save();
+      const updatedUser = await User.get(OR(AND(EQ('id', userId))));
+      expect(updatedUser.fullName).toBe(userFullName);
+    });
 
-  // // Filter users
-  const activeUsers = await User.filter({
-    filter: OR(AND(EQ('is_active', true))),
-    limit: 10,
+    test('should filter users by active status', async () => {
+      const activeUsers = await User.filter({
+        filter: OR(AND(EQ('is_active', true))),
+        limit: 10,
+      });
+
+      expect(activeUsers).toBeDefined();
+      expect(Array.isArray(activeUsers)).toBe(true);
+      activeUsers.forEach((user) => {
+        expect(user.isActive).toBe(true);
+      });
+    });
+
+    test('should count users by active status', async () => {
+      const userCount = await User.count({
+        filter: OR(AND(EQ('is_active', true))),
+      });
+
+      expect(userCount).toBeDefined();
+      expect(typeof userCount).toBe('number');
+      expect(userCount).toBeGreaterThanOrEqual(0);
+    });
+
+    test('should delete a user', async () => {
+      const user = await User.get(OR(AND(EQ('id', userId))));
+      await user.remove();
+
+      // Verify user is deleted (this might throw or return null depending on implementation)
+      await expect(User.get(OR(AND(EQ('id', userId))))).rejects.toThrow();
+    });
   });
 
-  // // Count users
-  const userCount = await User.count({
-    filter: OR(AND(EQ('is_active', true))),
+  describe('Bulk Operations', () => {
+    test('should bulk create multiple users', async () => {
+      const users = await User.bulkCreate([
+        {
+          email: 'user2@example.com',
+          fullName: 'User 2',
+          isActive: true,
+        },
+        {
+          email: 'user3@example.com',
+          fullName: 'User 3',
+          isActive: false,
+        },
+      ]);
+
+      expect(users).toBeDefined();
+      expect(users).toBe(2);
+    });
+
+    test('should retrieve bulk created users', async () => {
+      const user2 = await User.get(OR(AND(EQ('email', 'user2@example.com'))));
+      const user3 = await User.get(OR(AND(EQ('email', 'user3@example.com'))));
+
+      expect(user2).toBeDefined();
+      expect(user2.fullName).toBe('User 2');
+      expect(user2.isActive).toBe(true);
+
+      expect(user3).toBeDefined();
+      expect(user3.fullName).toBe('User 3');
+      expect(user3.isActive).toBe(false);
+    });
   });
-  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!');
-}
 
-// Run examples
-examples().catch(console.error);
+  afterAll(async () => {
+    await User.dropTable();
+  });
+});

package/tests/tsconfig.json

@@ -0,0 +1,8 @@
+// This file is used to let VSCode respect the tsconfig.json for this test folder
+{
+  "extends": "../tsconfig.json",
+  "include": [".", "../src"],
+  "compilerOptions": {
+    "noEmit": true
+  }
+}