@syntropix/database 0.0.4 → 0.0.6

package/src/types/basemodel.ts

@@ -1,558 +0,0 @@
-// BaseModel implementation with decorator support
-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';
-
-// Metadata keys
-const FIELDS_KEY = Symbol('fields');
-const TABLE_NAME_KEY = Symbol('tableName');
-const DESCRIPTION_KEY = Symbol('description');
-const INDEXES_KEY = Symbol('indexes');
-
-// Column decorator
-export function Column(
-  options: {
-    type?: string | Record<string, any>;
-    name?: string;
-    description?: string;
-    primary?: boolean;
-    nullable?: boolean;
-    auto_increment?: boolean;
-    default?: any;
-  } = {},
-) {
-  return function (target: any, propertyKey: string) {
-    const fields = Reflect.getMetadata(FIELDS_KEY, target.constructor) || {};
-
-    const fieldName = options.name || propertyKey.toLowerCase();
-    const column_type = options.type || 'Text';
-
-    const field = new (class extends Field {
-      constructor() {
-        super(column_type, {
-          name: fieldName,
-          description: options.description,
-          is_primary_key: options.primary,
-          is_nullable: options.nullable,
-          auto_increment: options.auto_increment,
-          default: options.default,
-        });
-      }
-    })();
-
-    fields[propertyKey] = field;
-    Reflect.defineMetadata(FIELDS_KEY, fields, target.constructor);
-  };
-}
-
-// Description decorator
-export function Description(description: string) {
-  return function (target: any) {
-    Reflect.defineMetadata(DESCRIPTION_KEY, description, target);
-  };
-}
-
-// ForeignKey decorator
-export function ForeignKey(
-  tableName: string,
-  columnName: string,
-  options: {
-    type?: string | Record<string, any>;
-    name?: string;
-    onDelete?: string;
-    onUpdate?: string;
-    description?: string;
-    nullable?: boolean;
-    default?: any;
-  } = {},
-) {
-  return function (target: any, propertyKey: string) {
-    const fields = Reflect.getMetadata(FIELDS_KEY, target.constructor) || {};
-
-    const field = new ForeignKeyField(options.type || 'Integer', tableName, columnName, {
-      onDelete: options.onDelete as any,
-      onUpdate: options.onUpdate as any,
-      description: options.description,
-      is_nullable: options.nullable,
-      default: options.default,
-    });
-    field.name = options.name || propertyKey.toLowerCase();
-
-    fields[propertyKey] = field;
-    Reflect.defineMetadata(FIELDS_KEY, fields, target.constructor);
-  };
-}
-
-export class BaseModel {
-  private _client?: SyntropixClient;
-  private _extra: Record<string, any> = {};
-
-  constructor(data: Record<string, any> = {}) {
-    const fields = this.getFields();
-
-    // Create a mapping from column names to property names
-    const columnToPropertyMap: Record<string, string> = {};
-    for (const [propertyName, field] of Object.entries(fields)) {
-      columnToPropertyMap[field.name] = propertyName;
-    }
-
-    for (const [key, value] of Object.entries(data)) {
-      // Check if key is a property name
-      if (key in fields) {
-        (this as any)[key] = value;
-      }
-      // Check if key is a column name
-      else if (key in columnToPropertyMap) {
-        (this as any)[columnToPropertyMap[key]] = value;
-      }
-      // Otherwise, store in _extra
-      else {
-        this._extra[key] = value;
-      }
-    }
-  }
-
-  // Static metadata getters
-  protected static getTableName(): string {
-    const tableName = Reflect.getMetadata(TABLE_NAME_KEY, this);
-    if (tableName) return tableName;
-
-    // Check for static tableName property
-    if ('tableName' in this && typeof (this as any).tableName === 'string') {
-      return (this as any).tableName;
-    }
-
-    return this.name.toLowerCase();
-  }
-
-  public static getDescription(): string {
-    const metadataDescription = Reflect.getMetadata(DESCRIPTION_KEY, this);
-    if (metadataDescription) return metadataDescription;
-
-    // Check for static description property as fallback
-    if ('description' in this && typeof (this as any).description === 'string') {
-      return (this as any).description;
-    }
-
-    return '';
-  }
-
-  protected static getIndexes(): Index[] {
-    return Reflect.getMetadata(INDEXES_KEY, this) || [];
-  }
-
-  protected static getFields(): Record<string, Field> {
-    const fields = Reflect.getMetadata(FIELDS_KEY, this) || {};
-
-    // Check if there's a primary key
-    let hasPrimaryKey = false;
-    for (const field of Object.values(fields) as Field[]) {
-      if (field.is_primary_key) {
-        hasPrimaryKey = true;
-        field.is_nullable = false;
-        break;
-      }
-    }
-
-    // If no primary key, add default 'id' field
-    if (!hasPrimaryKey && !('id' in fields)) {
-      fields['id'] = new IntegerField({
-        is_primary_key: true,
-        is_nullable: false,
-        auto_increment: true,
-        description: 'Primary key',
-      });
-      fields['id'].name = 'id';
-    }
-
-    return fields;
-  }
-
-  protected static getPrimaryKeyName(): string {
-    const fields = this.getFields();
-    for (const [key, field] of Object.entries(fields)) {
-      if (field.is_primary_key) {
-        return field.name;
-      }
-    }
-    return 'id';
-  }
-
-  protected static getAssociations(): ForeignKeyField[] {
-    const fields = this.getFields();
-    return Object.values(fields).filter((f) => f instanceof ForeignKeyField) as ForeignKeyField[];
-  }
-
-  // Instance metadata getters
-  protected getFields(): Record<string, Field> {
-    return (this.constructor as typeof BaseModel).getFields();
-  }
-
-  protected getTableName(): string {
-    return (this.constructor as typeof BaseModel).getTableName();
-  }
-
-  protected getPrimaryKeyName(): string {
-    return (this.constructor as typeof BaseModel).getPrimaryKeyName();
-  }
-
-  protected getPrimaryKey(): Field | undefined {
-    const fields = this.getFields();
-    for (const field of Object.values(fields)) {
-      if (field.is_primary_key) {
-        return field;
-      }
-    }
-    return undefined;
-  }
-
-  // Client getter
-  protected get client(): SyntropixClient {
-    if (!this._client) {
-      this._client = new SyntropixClient(new ClientConfig());
-    }
-    return this._client;
-  }
-
-  // Table operations
-  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) => ({
-      from_table: this.getTableName(),
-      from_column: f.name,
-      to_table: f.tableName,
-      to_column: f.columnName,
-      on_delete: f.onDelete,
-      on_update: f.onUpdate,
-    }));
-    const indexes = this.getIndexes();
-
-    const client = _client || new SyntropixClient(new ClientConfig());
-    return client.table.createTable({
-      name: this.getTableName(),
-      description: this.getDescription() || 'No description',
-      columns,
-      foreign_keys: foreignKeys,
-      indexes,
-    });
-  }
-
-  static async dropTable(_client?: SyntropixClient | null): Promise<any> {
-    const client = _client || new SyntropixClient(new ClientConfig());
-    return client.table.dropTable({ name: this.getTableName() });
-  }
-
-  static async renameTable(newName: string, _client?: SyntropixClient | null): Promise<any> {
-    const client = _client || new SyntropixClient(new ClientConfig());
-    return client.table.renameTable({
-      name: this.getTableName(),
-      new_name: newName,
-    });
-  }
-
-  static async truncateTable(_client?: SyntropixClient | null): Promise<any> {
-    const client = _client || new SyntropixClient(new ClientConfig());
-    return client.table.truncateTable({ name: this.getTableName() });
-  }
-
-  // Data operations
-  static async create<T extends BaseModel>(
-    this: new (data?: any) => T,
-    data: Record<string, any>,
-    _client?: SyntropixClient | null,
-  ): Promise<any> {
-    const model = this as any as typeof BaseModel;
-    const fields = model.getFields();
-    const columns: string[] = [];
-    const values: any[] = [];
-
-    for (const [key, value] of Object.entries(data)) {
-      if (key in fields) {
-        columns.push(fields[key].name);
-        values.push(value);
-      } else {
-        throw new Error(`Invalid field: ${key}`);
-      }
-    }
-
-    const client = _client || new SyntropixClient(new ClientConfig());
-    return client.data.insertOne({
-      table_name: model.getTableName(),
-      data: {
-        columns,
-        values: [values],
-      },
-    });
-  }
-
-  async save(_client?: SyntropixClient | null): Promise<any> {
-    const pk = this.getPrimaryKey();
-    const pkValue = (this as any)[this.getPrimaryKeyName()];
-    const fields = this.getFields();
-
-    if (pkValue === null || pkValue === undefined) {
-      const data: Record<string, any> = {};
-      for (const [key, field] of Object.entries(fields)) {
-        data[key] = (this as any)[key];
-      }
-      return (this.constructor as typeof BaseModel).create(data, _client);
-    }
-
-    const columns: string[] = [];
-    const values: any[] = [];
-    for (const [key, field] of Object.entries(fields)) {
-      if (field.name !== pk?.name) {
-        columns.push(field.name);
-        values.push((this as any)[key]);
-      }
-    }
-
-    return (
-      _client ||
-      this.client.data.updateByPrimaryKey(pkValue, {
-        table_name: this.getTableName(),
-        payload: {
-          filter: [[]],
-          columns,
-          values,
-        },
-      })
-    );
-  }
-
-  async remove(filter?: Filter, _client?: SyntropixClient | null): Promise<number> {
-    const pk = this.getPrimaryKey();
-    const pkValue = (this as any)[this.getPrimaryKeyName()];
-    const finalFilter = filter || OR(AND(EQ(pk?.name || 'id', pkValue)));
-
-    return (
-      _client ||
-      this.client.data.deleteData({
-        table_name: this.getTableName(),
-        payload: {
-          filter: finalFilter,
-        },
-      })
-    );
-  }
-
-  static async bulkCreate<T extends BaseModel>(
-    this: new (data?: any) => T,
-    datas: Record<string, any>[],
-    batchSize: number = 32,
-    _client?: SyntropixClient | null,
-  ): Promise<number> {
-    if (!datas.length) return 0;
-    if (batchSize <= 0) throw new Error('Batch size must be greater than 0');
-
-    const model = this as any as typeof BaseModel;
-    const fields = model.getFields();
-    let cnt = 0;
-    batchSize = Math.min(batchSize, 128);
-
-    const columns = Object.keys(datas[0]);
-    const columnsSet = new Set(columns);
-
-    for (const col of columns) {
-      if (!(col in fields)) {
-        throw new Error(`Invalid field: ${col}`);
-      }
-    }
-
-    let values: any[][] = [];
-    const client = _client || new SyntropixClient(new ClientConfig());
-
-    for (const data of datas) {
-      if (columnsSet.size !== new Set(Object.keys(data)).size || !columns.every((c) => c in data)) {
-        throw new Error('All data must have the same columns');
-      }
-
-      values.push(columns.map((c) => data[c]));
-
-      if (values.length === batchSize) {
-        cnt += await client.data.insertData({
-          table_name: model.getTableName(),
-          data: { columns: columns.map((c) => fields[c].name), values },
-        });
-        values = [];
-      }
-    }
-
-    if (values.length > 0) {
-      cnt += await client.data.insertData({
-        table_name: model.getTableName(),
-        data: { columns: columns.map((c) => fields[c].name), values },
-      });
-    }
-
-    return cnt;
-  }
-
-  static async update<T extends BaseModel>(
-    this: new (data?: any) => T,
-    filter: Filter,
-    data: Record<string, any>,
-    _client?: SyntropixClient | null,
-  ): Promise<number> {
-    const model = this as any as typeof BaseModel;
-    const fields = model.getFields();
-    const columns = Object.keys(data);
-
-    if (!columns.length) {
-      throw new Error('No columns to update');
-    }
-
-    for (const col of columns) {
-      if (!(col in fields)) {
-        throw new Error(`Invalid field: ${col}`);
-      }
-    }
-
-    const values = columns.map((c) => data[c]);
-    const client = _client || new SyntropixClient(new ClientConfig());
-
-    return client.data.updateData({
-      table_name: model.getTableName(),
-      payload: {
-        filter,
-        columns: columns.map((c) => fields[c].name),
-        values,
-      },
-    });
-  }
-
-  static async delete<T extends BaseModel>(
-    this: new (data?: any) => T,
-    filter: Filter,
-    _client?: SyntropixClient | null,
-  ): Promise<number> {
-    const model = this as any as typeof BaseModel;
-    const client = _client || new SyntropixClient(new ClientConfig());
-
-    return client.data.deleteData({
-      table_name: model.getTableName(),
-      payload: { filter },
-    });
-  }
-
-  static async get<T extends BaseModel>(
-    this: new (data?: any) => T,
-    filter: Filter,
-    select?: string[],
-    _client?: SyntropixClient | null,
-  ): Promise<T> {
-    const model = this as any as typeof BaseModel;
-    const fields = model.getFields();
-    const client = _client || new SyntropixClient(new ClientConfig());
-
-    const data = await client.data.queryOne({
-      table_name: model.getTableName(),
-      query: {
-        filter,
-        select: select || Object.values(fields).map((f) => f.name),
-        limit: 1,
-      },
-    });
-
-    return new this(data);
-  }
-
-  static async filter<T extends BaseModel>(
-    this: new (data?: any) => T,
-    options: {
-      filter: Filter;
-      sort?: Sort[];
-      aggregate?: Aggregate[];
-      join?: Join;
-      limit?: number;
-      offset?: number;
-      groupBy?: GroupBy;
-      select?: string[];
-      _client?: SyntropixClient | null;
-    },
-  ): Promise<T[]> {
-    const model = this as any as typeof BaseModel;
-    const client = options._client || new SyntropixClient(new ClientConfig());
-
-    const data = await client.data.queryMany({
-      table_name: model.getTableName(),
-      query: {
-        filter: options.filter,
-        sort: options.sort,
-        aggregate: options.aggregate,
-        join: options.join ? [options.join] : undefined,
-        limit: options.limit,
-        offset: options.offset,
-        group_by: options.groupBy,
-        select: options.select,
-      },
-    });
-
-    return data.map((item: any) => new this(item));
-  }
-
-  static async count<T extends BaseModel>(
-    this: new (data?: any) => T,
-    options: {
-      filter?: Filter;
-      join?: Join;
-      groupBy?: GroupBy;
-      _client?: SyntropixClient | null;
-    } = {},
-  ): Promise<number> {
-    const model = this as any as typeof BaseModel;
-    const client = options._client || new SyntropixClient(new ClientConfig());
-
-    const data = await client.data.queryMany({
-      table_name: model.getTableName(),
-      query: {
-        filter: options.filter || [[GTE('id', Value(0))]],
-        aggregate: [
-          {
-            column: 'id',
-            function: AggregateFunction.COUNT,
-            alias: 'count',
-          },
-        ],
-        join: options.join ? [options.join] : undefined,
-        limit: 1,
-        offset: 0,
-        group_by: options.groupBy,
-        select: ['count'],
-      },
-    });
-
-    return data.length > 0 ? data[0].count : 0;
-  }
-
-  toString(): string {
-    const fields = this.getFields();
-    const data: Record<string, any> = {};
-
-    for (const key of Object.keys(fields)) {
-      const value = (this as any)[key];
-      if (!(value instanceof Field)) {
-        data[key] = value;
-      }
-    }
-
-    data._extra = this._extra;
-    return `${this.constructor.name}(${JSON.stringify(data).slice(1, -1)})`;
-  }
-
-  toJSON(): Record<string, any> {
-    const fields = this.getFields();
-    const data: Record<string, any> = {};
-
-    for (const key of Object.keys(fields)) {
-      data[key] = (this as any)[key];
-    }
-
-    return { ...data, ...this._extra };
-  }
-}

package/src/types/common.ts

@@ -1,83 +0,0 @@
-// 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/data-type.ts

@@ -1,23 +0,0 @@
-// Data type definitions for database columns
-export class DataType {
-  // Basic types
-  static readonly Integer = 'Integer';
-  static readonly String = (maxLength: number) => ({ type: 'String', maxLength });
-  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';
-
-  // Complex types
-  static readonly Vector = (dimensions: number) => ({ type: 'Vector', dimensions });
-  static readonly Array = (dataType: string | Record<string, any>) => ({ type: 'Array', dataType });
-  static readonly Enum = (name: string, variants: string[]) => ({ type: 'Enum', name, variants });
-  static readonly Money = (precision: number, scale: number) => ({ type: 'Money', precision, scale });
-  static readonly Decimal = (precision: number, scale: number) => ({ type: 'Decimal', precision, scale });
-}
-
-export type ColumnType = string | Record<string, any>;

package/src/types/dto/base.ts

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

package/src/types/dto/table.ts

@@ -1,21 +0,0 @@
-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[];
-}