@syntropix/database 0.1.0 → 0.1.1

package/dist/index.cjs

@@ -0,0 +1,1199 @@
+'use strict';
+
+var axios = require('axios');
+require('reflect-metadata');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var axios__default = /*#__PURE__*/_interopDefault(axios);
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var Client = class {
+  static {
+    __name(this, "Client");
+  }
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  headers() {
+    return {
+      "Content-Type": "application/json",
+      Authorization: this.config.apiKey || ""
+    };
+  }
+  url(path) {
+    if (path.startsWith("/")) {
+      path = path.slice(1);
+    }
+    return `${this.config.baseUrl}${path}`;
+  }
+  async get(path, data = {}) {
+    const response = await axios__default.default.get(this.url(path), {
+      headers: this.headers(),
+      params: data
+    });
+    if (response.status !== 200) {
+      throw new Error(`Failed to get data: ${response.statusText}`);
+    }
+    return response.data;
+  }
+  async post(path, data = {}) {
+    const response = await axios__default.default.post(this.url(path), data, {
+      headers: this.headers()
+    });
+    if (response.status !== 200) {
+      throw new Error(`Failed to post data: ${response.statusText}`);
+    }
+    return response.data;
+  }
+};
+
+// src/core/config.ts
+var ClientConfig = class {
+  static {
+    __name(this, "ClientConfig");
+  }
+  apiKey;
+  baseUrl;
+  timeout;
+  retries;
+  constructor(config) {
+    this.apiKey = config?.apiKey || process.env.SYNTROPIX_API_KEY;
+    this.baseUrl = config?.baseUrl || process.env.SYNTROPIX_API_URL;
+    this.timeout = config?.timeout || process.env.SYNTROPIX_API_TIMEOUT;
+    this.retries = config?.retries || process.env.SYNTROPIX_API_RETRIES;
+    if (!this.apiKey || !this.baseUrl) {
+      throw new Error("API key and base URL are required");
+    }
+    if (!this.timeout) {
+      this.timeout = 1e4;
+    }
+    if (!this.retries) {
+      this.retries = 3;
+    }
+    if (!this.baseUrl.endsWith("/")) {
+      this.baseUrl += "/";
+    }
+  }
+};
+
+// src/types/filter.ts
+var SortType = /* @__PURE__ */ (function(SortType2) {
+  SortType2["Descending"] = "Descending";
+  SortType2["Ascending"] = "Ascending";
+  return SortType2;
+})({});
+var FilterOperation = /* @__PURE__ */ (function(FilterOperation2) {
+  FilterOperation2["LT"] = "LT";
+  FilterOperation2["LTE"] = "LTE";
+  FilterOperation2["GT"] = "GT";
+  FilterOperation2["GTE"] = "GTE";
+  FilterOperation2["EQ"] = "EQ";
+  FilterOperation2["NEQ"] = "NEQ";
+  FilterOperation2["Between"] = "Between";
+  FilterOperation2["In"] = "In";
+  FilterOperation2["Contains"] = "Contains";
+  FilterOperation2["Overlap"] = "Overlap";
+  FilterOperation2["NotIn"] = "NotIn";
+  FilterOperation2["Like"] = "Like";
+  FilterOperation2["NotLike"] = "NotLike";
+  FilterOperation2["ILike"] = "ILike";
+  FilterOperation2["NotILike"] = "NotILike";
+  FilterOperation2["IsNull"] = "IsNull";
+  FilterOperation2["IsNotNull"] = "IsNotNull";
+  FilterOperation2["Similarity"] = "Similarity";
+  FilterOperation2["SimilarityDistance"] = "SimilarityDistance";
+  FilterOperation2["WordSimilarity"] = "WordSimilarity";
+  FilterOperation2["WordSimilarityDistance"] = "WordSimilarityDistance";
+  FilterOperation2["StrictWordSimilarity"] = "StrictWordSimilarity";
+  FilterOperation2["StrictWordSimilarityDistance"] = "StrictWordSimilarityDistance";
+  FilterOperation2["EuclideanDistance"] = "EuclideanDistance";
+  FilterOperation2["NegativeInnerProduct"] = "NegativeInnerProduct";
+  FilterOperation2["CosineDistance"] = "CosineDistance";
+  return FilterOperation2;
+})({});
+var AND = /* @__PURE__ */ __name((...conditions) => conditions, "AND");
+var OR = /* @__PURE__ */ __name((...conditions) => conditions, "OR");
+var EQ = /* @__PURE__ */ __name((field, value) => ({
+  column: field,
+  operator: "EQ",
+  staticValue: value
+}), "EQ");
+var NE = /* @__PURE__ */ __name((field, value) => ({
+  column: field,
+  operator: "NEQ",
+  staticValue: value
+}), "NE");
+var GT = /* @__PURE__ */ __name((field, value) => ({
+  column: field,
+  operator: "GT",
+  staticValue: value
+}), "GT");
+var GTE = /* @__PURE__ */ __name((field, value) => ({
+  column: field,
+  operator: "GTE",
+  staticValue: value
+}), "GTE");
+var LT = /* @__PURE__ */ __name((field, value) => ({
+  column: field,
+  operator: "LT",
+  staticValue: value
+}), "LT");
+var LTE = /* @__PURE__ */ __name((field, value) => ({
+  column: field,
+  operator: "LTE",
+  staticValue: value
+}), "LTE");
+var IN = /* @__PURE__ */ __name((field, values) => ({
+  column: field,
+  operator: "In",
+  staticValue: values
+}), "IN");
+var CONTAINS = /* @__PURE__ */ __name((field, value) => ({
+  column: field,
+  operator: "Contains",
+  staticValue: value
+}), "CONTAINS");
+var OVERLAP = /* @__PURE__ */ __name((field, value) => ({
+  column: field,
+  operator: "Overlap",
+  staticValue: value
+}), "OVERLAP");
+var I_LIKE = /* @__PURE__ */ __name((field, pattern) => ({
+  column: field,
+  operator: "ILike",
+  staticValue: pattern
+}), "I_LIKE");
+var NOT_I_LIKE = /* @__PURE__ */ __name((field, pattern) => ({
+  column: field,
+  operator: "NotILike",
+  staticValue: pattern
+}), "NOT_I_LIKE");
+var NOT_IN = /* @__PURE__ */ __name((field, values) => ({
+  column: field,
+  operator: "NotIn",
+  staticValue: values
+}), "NOT_IN");
+var LIKE = /* @__PURE__ */ __name((field, pattern) => ({
+  column: field,
+  operator: "Like",
+  staticValue: pattern
+}), "LIKE");
+var NOT_LIKE = /* @__PURE__ */ __name((field, pattern) => ({
+  column: field,
+  operator: "NotLike",
+  staticValue: pattern
+}), "NOT_LIKE");
+var IS_NULL = /* @__PURE__ */ __name((field) => ({
+  column: field,
+  operator: "IsNull"
+}), "IS_NULL");
+var IS_NOT_NULL = /* @__PURE__ */ __name((field) => ({
+  column: field,
+  operator: "IsNotNull"
+}), "IS_NOT_NULL");
+var BETWEEN = /* @__PURE__ */ __name((field, min, max) => ({
+  column: field,
+  operator: "Between",
+  staticValue: [
+    min,
+    max
+  ]
+}), "BETWEEN");
+var EQ_COL = /* @__PURE__ */ __name((field, otherField) => ({
+  column: field,
+  operator: "EQ",
+  columnValue: otherField
+}), "EQ_COL");
+var NE_COL = /* @__PURE__ */ __name((field, otherField) => ({
+  column: field,
+  operator: "NEQ",
+  columnValue: otherField
+}), "NE_COL");
+var GT_COL = /* @__PURE__ */ __name((field, otherField) => ({
+  column: field,
+  operator: "GT",
+  columnValue: otherField
+}), "GT_COL");
+var GTE_COL = /* @__PURE__ */ __name((field, otherField) => ({
+  column: field,
+  operator: "GTE",
+  columnValue: otherField
+}), "GTE_COL");
+var LT_COL = /* @__PURE__ */ __name((field, otherField) => ({
+  column: field,
+  operator: "LT",
+  columnValue: otherField
+}), "LT_COL");
+var LTE_COL = /* @__PURE__ */ __name((field, otherField) => ({
+  column: field,
+  operator: "LTE",
+  columnValue: otherField
+}), "LTE_COL");
+var SIMILARITY = /* @__PURE__ */ __name((field, value, options) => ({
+  column: field,
+  operator: "Similarity",
+  staticValue: value,
+  simiarityOptions: options
+}), "SIMILARITY");
+var SIMILARITY_DISTANCE = /* @__PURE__ */ __name((field, value, options) => ({
+  column: field,
+  operator: "SimilarityDistance",
+  staticValue: value,
+  simiarityOptions: options
+}), "SIMILARITY_DISTANCE");
+var WORD_SIMILARITY = /* @__PURE__ */ __name((field, value, options) => ({
+  column: field,
+  operator: "WordSimilarity",
+  staticValue: value,
+  simiarityOptions: options
+}), "WORD_SIMILARITY");
+var WORD_SIMILARITY_DISTANCE = /* @__PURE__ */ __name((field, value, options) => ({
+  column: field,
+  operator: "WordSimilarityDistance",
+  staticValue: value,
+  simiarityOptions: options
+}), "WORD_SIMILARITY_DISTANCE");
+var STRICT_WORD_SIMILARITY = /* @__PURE__ */ __name((field, value, options) => ({
+  column: field,
+  operator: "StrictWordSimilarity",
+  staticValue: value,
+  simiarityOptions: options
+}), "STRICT_WORD_SIMILARITY");
+var STRICT_WORD_SIMILARITY_DISTANCE = /* @__PURE__ */ __name((field, value, options) => ({
+  column: field,
+  operator: "StrictWordSimilarityDistance",
+  staticValue: value,
+  simiarityOptions: options
+}), "STRICT_WORD_SIMILARITY_DISTANCE");
+var EUCLIDEAN_DISTANCE = /* @__PURE__ */ __name((field, value, options) => ({
+  column: field,
+  operator: "EuclideanDistance",
+  staticValue: value,
+  simiarityOptions: options
+}), "EUCLIDEAN_DISTANCE");
+var NEGATIVE_INNER_PRODUCT = /* @__PURE__ */ __name((field, value, options) => ({
+  column: field,
+  operator: "NegativeInnerProduct",
+  staticValue: value,
+  simiarityOptions: options
+}), "NEGATIVE_INNER_PRODUCT");
+var COSINE_DISTANCE = /* @__PURE__ */ __name((field, value, options) => ({
+  column: field,
+  operator: "CosineDistance",
+  staticValue: value,
+  simiarityOptions: options
+}), "COSINE_DISTANCE");
+var Value = /* @__PURE__ */ __name((value) => value, "Value");
+function FilterWrapper(filter) {
+  if (filter === void 0) {
+    return void 0;
+  }
+  if (!Array.isArray(filter)) {
+    return OR(AND(filter));
+  } else if (!filter.every((item) => Array.isArray(item))) {
+    return OR(filter);
+  } else {
+    return filter;
+  }
+}
+__name(FilterWrapper, "FilterWrapper");
+
+// src/core/data-client.ts
+var DataClient = class {
+  static {
+    __name(this, "DataClient");
+  }
+  client;
+  constructor(config = new ClientConfig()) {
+    this.client = new Client(config);
+  }
+  async insertData(data) {
+    const response = await this.client.post("/insert", data);
+    if (response.status === "success") {
+      return response.data;
+    }
+    throw new Error(response.message);
+  }
+  async insertOne(data) {
+    const response = await this.client.post("/insert/one", data);
+    if (response.status === "success") {
+      return response.data;
+    }
+    throw new Error(response.message);
+  }
+  async updateByPrimaryKey(pk, data) {
+    const response = await this.client.post(`/update/${pk}`, data);
+    if (response.status === "success") {
+      return response.data;
+    }
+    throw new Error(response.message);
+  }
+  async queryOne(data, model) {
+    data.query.filter = FilterWrapper(data.query.filter);
+    const response = await this.client.post("/query", {
+      One: data
+    });
+    if (response.status === "success") {
+      const responseData = response.data;
+      if (model !== void 0) {
+        return new model(responseData);
+      }
+      return responseData;
+    }
+    throw new Error(response.message);
+  }
+  async queryMany(data, model) {
+    data.query.filter = FilterWrapper(data.query.filter);
+    const response = await this.client.post("/query", {
+      Many: data
+    });
+    if (response.status === "success") {
+      const responseData = response.data;
+      if (model !== void 0) {
+        return responseData.map((item) => new model(item));
+      }
+      return responseData;
+    }
+    throw new Error(response.message);
+  }
+  async updateData(data) {
+    const response = await this.client.post("/update", data);
+    if (response.status === "success") {
+      return response.data;
+    }
+    throw new Error(response.message);
+  }
+  async deleteData(data) {
+    const response = await this.client.post("/delete", data);
+    if (response.status === "success") {
+      return response.data;
+    }
+    throw new Error(response.message);
+  }
+};
+
+// src/core/table-client.ts
+var TableClient = class {
+  static {
+    __name(this, "TableClient");
+  }
+  client;
+  constructor(config = new ClientConfig()) {
+    this.client = new Client(config);
+  }
+  async createTable(data) {
+    const response = await this.client.post("/table/create", data);
+    if (response.status === "success") {
+      return response.data;
+    }
+    throw new Error(response.message);
+  }
+  async dropTable(data) {
+    const response = await this.client.post("/table/drop", data);
+    if (response.status === "success") {
+      return response.data;
+    }
+    throw new Error(response.message);
+  }
+  async renameTable(data) {
+    const response = await this.client.post("/table/rename", data);
+    if (response.status === "success") {
+      return response.data;
+    }
+    throw new Error(response.message);
+  }
+  async truncateTable(data) {
+    const response = await this.client.post("/table/truncate", data);
+    if (response.status === "success") {
+      return response.data;
+    }
+    throw new Error(response.message);
+  }
+  async addColumn(data) {
+    const response = await this.client.post("/table/column/add", data);
+    if (response.status === "success") {
+      return response.data;
+    }
+    throw new Error(response.message);
+  }
+  async dropColumn(data) {
+    const response = await this.client.post("/table/column/drop", data);
+    if (response.status === "success") {
+      return response.data;
+    }
+    throw new Error(response.message);
+  }
+  async modifyColumn(data) {
+    const response = await this.client.post("/table/column/modify", data);
+    if (response.status === "success") {
+      return response.data;
+    }
+    throw new Error(response.message);
+  }
+  async getTableSchema(data) {
+    const response = await this.client.post("/table/schema", data);
+    if (response.status === "success") {
+      return response.data;
+    }
+    throw new Error(response.message);
+  }
+  async getTableList(data) {
+    const response = await this.client.get("/table/list", data);
+    if (response.status === "success") {
+      return response.data;
+    }
+    throw new Error(response.message);
+  }
+};
+
+// src/core/syntropix.ts
+var SyntropixClient = class {
+  static {
+    __name(this, "SyntropixClient");
+  }
+  config;
+  _tableClient;
+  _dataClient;
+  constructor(config = new ClientConfig()) {
+    this.config = config;
+  }
+  get table() {
+    if (!this._tableClient) {
+      this._tableClient = new TableClient(this.config);
+    }
+    return this._tableClient;
+  }
+  get data() {
+    if (!this._dataClient) {
+      this._dataClient = new DataClient(this.config);
+    }
+    return this._dataClient;
+  }
+};
+
+// src/types/common.ts
+var ForeignKeyAction = /* @__PURE__ */ (function(ForeignKeyAction2) {
+  ForeignKeyAction2["Cascade"] = "Cascade";
+  ForeignKeyAction2["Restrict"] = "Restrict";
+  ForeignKeyAction2["SetNull"] = "SetNull";
+  ForeignKeyAction2["NoAction"] = "NoAction";
+  ForeignKeyAction2["SetDefault"] = "SetDefault";
+  return ForeignKeyAction2;
+})({});
+var AggregateFunction = /* @__PURE__ */ (function(AggregateFunction2) {
+  AggregateFunction2["Count"] = "Count";
+  AggregateFunction2["Sum"] = "Sum";
+  AggregateFunction2["Avg"] = "Avg";
+  AggregateFunction2["Min"] = "Min";
+  AggregateFunction2["Max"] = "Max";
+  AggregateFunction2["CountDistinct"] = "CountDistinct";
+  return AggregateFunction2;
+})({});
+
+// src/types/data-type.ts
+var ColumnDataType = {
+  Integer: "Integer",
+  String: /* @__PURE__ */ __name((maxLength) => ({
+    String: maxLength
+  }), "String"),
+  Text: "Text",
+  Boolean: "Boolean",
+  DateTime: "DateTime",
+  Timestamp: "Timestamp",
+  Date: "Date",
+  Json: "Json",
+  Uuid: "Uuid",
+  Double: "Double",
+  Vector: /* @__PURE__ */ __name((dimensions) => ({
+    Vector: dimensions
+  }), "Vector"),
+  Array: /* @__PURE__ */ __name((dataType) => ({
+    Array: dataType
+  }), "Array"),
+  Enum: /* @__PURE__ */ __name((name, variants) => ({
+    Enum: {
+      name,
+      variants
+    }
+  }), "Enum"),
+  Money: /* @__PURE__ */ __name((precision, scale) => ({
+    Money: precision && scale ? [
+      precision,
+      scale
+    ] : null
+  }), "Money"),
+  Decimal: /* @__PURE__ */ __name((precision, scale) => ({
+    Decimal: precision && scale ? [
+      precision,
+      scale
+    ] : null
+  }), "Decimal")
+};
+
+// src/types/field.ts
+var Field = class {
+  static {
+    __name(this, "Field");
+  }
+  name = "";
+  description = "";
+  columnType;
+  isPrimaryKey = false;
+  isNullable = false;
+  autoIncrement = false;
+  default;
+  defaultAccess;
+  constructor(columnType, options = {}) {
+    this.columnType = columnType;
+    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
+    };
+  }
+};
+var ForeignKeyField = class extends Field {
+  static {
+    __name(this, "ForeignKeyField");
+  }
+  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;
+  }
+};
+var StringField = class extends Field {
+  static {
+    __name(this, "StringField");
+  }
+  constructor(maxLength, options = {}) {
+    super(ColumnDataType.String(maxLength), options);
+  }
+};
+var TextField = class extends Field {
+  static {
+    __name(this, "TextField");
+  }
+  constructor(options = {}) {
+    super(ColumnDataType.Text, options);
+  }
+};
+var IntegerField = class extends Field {
+  static {
+    __name(this, "IntegerField");
+  }
+  constructor(options = {}) {
+    super(ColumnDataType.Integer, options);
+  }
+};
+var BooleanField = class extends Field {
+  static {
+    __name(this, "BooleanField");
+  }
+  constructor(options = {}) {
+    super(ColumnDataType.Boolean, options);
+  }
+};
+var DateTimeField = class extends Field {
+  static {
+    __name(this, "DateTimeField");
+  }
+  constructor(options = {}) {
+    super(ColumnDataType.DateTime, options);
+  }
+};
+var TimestampField = class extends Field {
+  static {
+    __name(this, "TimestampField");
+  }
+  constructor(options = {}) {
+    super(ColumnDataType.Timestamp, options);
+  }
+};
+var DateField = class extends Field {
+  static {
+    __name(this, "DateField");
+  }
+  constructor(options = {}) {
+    super(ColumnDataType.Date, options);
+  }
+};
+var JsonField = class extends Field {
+  static {
+    __name(this, "JsonField");
+  }
+  constructor(options = {}) {
+    super(ColumnDataType.Json, options);
+  }
+};
+var UuidField = class extends Field {
+  static {
+    __name(this, "UuidField");
+  }
+  constructor(options = {}) {
+    super(ColumnDataType.Uuid, options);
+  }
+};
+var VectorField = class extends Field {
+  static {
+    __name(this, "VectorField");
+  }
+  constructor(dimensions, options = {}) {
+    super(ColumnDataType.Vector(dimensions), options);
+  }
+};
+var ArrayField = class extends Field {
+  static {
+    __name(this, "ArrayField");
+  }
+  constructor(dataType, options = {}) {
+    super(ColumnDataType.Array(dataType), options);
+  }
+};
+var EnumField = class extends Field {
+  static {
+    __name(this, "EnumField");
+  }
+  constructor(name, variants, options = {}) {
+    super(ColumnDataType.Enum(name, variants), options);
+  }
+};
+var MoneyField = class extends Field {
+  static {
+    __name(this, "MoneyField");
+  }
+  constructor(precision, scale, options = {}) {
+    super(ColumnDataType.Money(precision, scale), options);
+  }
+};
+var DecimalField = class extends Field {
+  static {
+    __name(this, "DecimalField");
+  }
+  constructor(precision, scale, options = {}) {
+    super(ColumnDataType.Decimal(precision, scale), options);
+  }
+};
+var DoubleField = class extends Field {
+  static {
+    __name(this, "DoubleField");
+  }
+  constructor(options = {}) {
+    super(ColumnDataType.Double, options);
+  }
+};
+var FIELDS_KEY = Symbol("fields");
+var TABLE_NAME_KEY = Symbol("tableName");
+var DESCRIPTION_KEY = Symbol("description");
+var INDEXES_KEY = Symbol("indexes");
+function Column(options = {}) {
+  return function(target, propertyKey) {
+    const fields = Reflect.getMetadata(FIELDS_KEY, target.constructor) || {};
+    const fieldName = options.name || propertyKey.toLowerCase();
+    const columnType = options.type || ColumnDataType.Text;
+    const field = new class extends Field {
+      constructor() {
+        super(columnType, {
+          name: fieldName,
+          description: options.description,
+          isPrimaryKey: options.primary,
+          isNullable: options.nullable,
+          autoIncrement: options.autoIncrement,
+          default: options.default
+        });
+      }
+    }();
+    fields[propertyKey] = field;
+    Reflect.defineMetadata(FIELDS_KEY, fields, target.constructor);
+  };
+}
+__name(Column, "Column");
+function ForeignKey(tableName, columnName, options = {}) {
+  return function(target, propertyKey) {
+    const fields = Reflect.getMetadata(FIELDS_KEY, target.constructor) || {};
+    const field = new ForeignKeyField(options.type || ColumnDataType.Integer, tableName, columnName, {
+      onDelete: options.onDelete,
+      onUpdate: options.onUpdate,
+      description: options.description,
+      isNullable: options.nullable,
+      default: options.default
+    });
+    field.name = options.name || propertyKey.toLowerCase();
+    fields[propertyKey] = field;
+    Reflect.defineMetadata(FIELDS_KEY, fields, target.constructor);
+  };
+}
+__name(ForeignKey, "ForeignKey");
+var BaseModel = class {
+  static {
+    __name(this, "BaseModel");
+  }
+  _client;
+  _extra = {};
+  constructor(data = {}) {
+    const fields = this.getFields();
+    const columnToPropertyMap = {};
+    for (const [propertyName, field] of Object.entries(fields)) {
+      columnToPropertyMap[field.name] = propertyName;
+    }
+    for (const [key, value] of Object.entries(data)) {
+      if (key in fields) {
+        this[key] = value;
+      } else if (key in columnToPropertyMap) {
+        this[columnToPropertyMap[key]] = value;
+      } else {
+        this._extra[key] = value;
+      }
+    }
+  }
+  // Static metadata getters
+  static getTableName() {
+    const tableName = Reflect.getMetadata(TABLE_NAME_KEY, this);
+    if (tableName) return tableName;
+    if ("tableName" in this && typeof this.tableName === "string") {
+      return this.tableName;
+    }
+    return this.name.toLowerCase();
+  }
+  static getDescription() {
+    const metadataDescription = Reflect.getMetadata(DESCRIPTION_KEY, this);
+    if (metadataDescription) return metadataDescription;
+    if ("description" in this && typeof this.description === "string") {
+      return this.description;
+    }
+    return "";
+  }
+  static getIndexes() {
+    return Reflect.getMetadata(INDEXES_KEY, this) || [];
+  }
+  static getFields() {
+    const fields = Reflect.getMetadata(FIELDS_KEY, this) || {};
+    let hasPrimaryKey = false;
+    for (const field of Object.values(fields)) {
+      if (field.isPrimaryKey) {
+        hasPrimaryKey = true;
+        field.isNullable = false;
+        break;
+      }
+    }
+    if (!hasPrimaryKey && !("id" in fields)) {
+      fields["id"] = new IntegerField({
+        isPrimaryKey: true,
+        isNullable: false,
+        autoIncrement: true,
+        description: "Primary key"
+      });
+      fields["id"].name = "id";
+    }
+    return fields;
+  }
+  static getPrimaryKeyName() {
+    const fields = this.getFields();
+    for (const [key, field] of Object.entries(fields)) {
+      if (field.isPrimaryKey) {
+        return field.name;
+      }
+    }
+    return "id";
+  }
+  static getAssociations() {
+    const fields = this.getFields();
+    return Object.values(fields).filter((f) => f instanceof ForeignKeyField);
+  }
+  // Instance metadata getters
+  getFields() {
+    return this.constructor.getFields();
+  }
+  getTableName() {
+    return this.constructor.getTableName();
+  }
+  getPrimaryKeyName() {
+    return this.constructor.getPrimaryKeyName();
+  }
+  getPrimaryKey() {
+    const fields = this.getFields();
+    for (const field of Object.values(fields)) {
+      if (field.isPrimaryKey) {
+        return field;
+      }
+    }
+    return void 0;
+  }
+  // Client getter
+  get client() {
+    if (!this._client) {
+      this._client = new SyntropixClient(new ClientConfig());
+    }
+    return this._client;
+  }
+  // Table operations
+  static async createTable(_client) {
+    const fields = this.getFields();
+    const columns = Object.values(fields).map((f) => f.into());
+    const foreignKeys = this.getAssociations().map((f) => ({
+      fromTableName: this.getTableName(),
+      fromColumnName: f.name,
+      toTableName: f.tableName,
+      toColumnName: f.columnName,
+      onDelete: f.onDelete,
+      onUpdate: 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,
+      foreignKeys,
+      indexes
+    });
+  }
+  static async dropTable(_client) {
+    const client = _client || new SyntropixClient(new ClientConfig());
+    return client.table.dropTable({
+      tableName: this.getTableName()
+    });
+  }
+  static async renameTable(newName, _client) {
+    const client = _client || new SyntropixClient(new ClientConfig());
+    return client.table.renameTable({
+      tableName: this.getTableName(),
+      newTableName: newName
+    });
+  }
+  static async truncateTable(_client) {
+    const client = _client || new SyntropixClient(new ClientConfig());
+    return client.table.truncateTable({
+      tableName: this.getTableName()
+    });
+  }
+  // Data operations
+  static async create(data, _client) {
+    const model = this;
+    const fields = model.getFields();
+    const columns = [];
+    const values = [];
+    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({
+      tableName: model.getTableName(),
+      data: {
+        columns,
+        values: [
+          values
+        ]
+      }
+    });
+  }
+  async save(_client) {
+    const pk = this.getPrimaryKey();
+    const pkValue = this[this.getPrimaryKeyName()];
+    const fields = this.getFields();
+    if (pkValue === null || pkValue === void 0) {
+      const data = {};
+      for (const [key, field] of Object.entries(fields)) {
+        data[key] = this[key];
+      }
+      return this.constructor.create(data, _client);
+    }
+    const columns = [];
+    const values = [];
+    for (const [key, field] of Object.entries(fields)) {
+      if (field.name !== pk?.name) {
+        columns.push(field.name);
+        values.push(this[key]);
+      }
+    }
+    return _client || this.client.data.updateByPrimaryKey(pkValue, {
+      tableName: this.getTableName(),
+      payload: {
+        filter: [
+          []
+        ],
+        columns,
+        values
+      }
+    });
+  }
+  async remove(filter, _client) {
+    const pk = this.getPrimaryKey();
+    const pkValue = this[this.getPrimaryKeyName()];
+    const finalFilter = filter || OR(AND(EQ(pk?.name || "id", pkValue)));
+    return _client || this.client.data.deleteData({
+      tableName: this.getTableName(),
+      payload: {
+        filter: finalFilter
+      }
+    });
+  }
+  static async bulkCreate(datas, batchSize = 32, _client) {
+    if (!datas.length) return 0;
+    if (batchSize <= 0) throw new Error("Batch size must be greater than 0");
+    const model = this;
+    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 = [];
+    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({
+          tableName: model.getTableName(),
+          data: {
+            columns: columns.map((c) => fields[c].name),
+            values
+          }
+        });
+        values = [];
+      }
+    }
+    if (values.length > 0) {
+      cnt += await client.data.insertData({
+        tableName: model.getTableName(),
+        data: {
+          columns: columns.map((c) => fields[c].name),
+          values
+        }
+      });
+    }
+    return cnt;
+  }
+  static async update(filter, data, _client) {
+    const model = this;
+    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({
+      tableName: model.getTableName(),
+      payload: {
+        filter,
+        columns: columns.map((c) => fields[c].name),
+        values
+      }
+    });
+  }
+  static async delete(filter, _client) {
+    const model = this;
+    const client = _client || new SyntropixClient(new ClientConfig());
+    return client.data.deleteData({
+      tableName: model.getTableName(),
+      payload: {
+        filter
+      }
+    });
+  }
+  static async get(filter, select, _client) {
+    const model = this;
+    const fields = model.getFields();
+    const client = _client || new SyntropixClient(new ClientConfig());
+    const data = await client.data.queryOne({
+      tableName: model.getTableName(),
+      query: {
+        filter,
+        select: select || Object.values(fields).map((f) => f.name),
+        limit: 1
+      }
+    });
+    return new this(data);
+  }
+  static async filter(options) {
+    const model = this;
+    const client = options._client || new SyntropixClient(new ClientConfig());
+    const data = await client.data.queryMany({
+      tableName: model.getTableName(),
+      query: {
+        filter: options.filter,
+        sort: options.sort,
+        aggregate: options.aggregate,
+        join: options.join ? [
+          options.join
+        ] : void 0,
+        limit: options.limit,
+        offset: options.offset,
+        groupBy: options.groupBy,
+        select: options.select
+      }
+    });
+    return data.map((item) => new this(item));
+  }
+  static async count(options = {}) {
+    const model = this;
+    const client = options._client || new SyntropixClient(new ClientConfig());
+    const data = await client.data.queryMany({
+      tableName: model.getTableName(),
+      query: {
+        filter: options.filter || [
+          [
+            GTE("id", Value(0))
+          ]
+        ],
+        aggregate: [
+          {
+            column: "id",
+            function: AggregateFunction.Count,
+            alias: "count"
+          }
+        ],
+        join: options.join ? [
+          options.join
+        ] : void 0,
+        limit: 1,
+        offset: 0,
+        groupBy: options.groupBy,
+        select: [
+          "count"
+        ]
+      }
+    });
+    return data.length > 0 ? data[0].count : 0;
+  }
+  toString() {
+    const fields = this.getFields();
+    const data = {};
+    for (const key of Object.keys(fields)) {
+      const value = this[key];
+      if (!(value instanceof Field)) {
+        data[key] = value;
+      }
+    }
+    data._extra = this._extra;
+    return `${this.constructor.name}(${JSON.stringify(data).slice(1, -1)})`;
+  }
+  toJSON() {
+    const fields = this.getFields();
+    const data = {};
+    for (const key of Object.keys(fields)) {
+      data[key] = this[key];
+    }
+    return {
+      ...data,
+      ...this._extra
+    };
+  }
+};
+
+// src/types/requests.ts
+var SyntropixDBAccessType = {
+  None: "None",
+  Read: "Read",
+  Write: "Write",
+  Admin: "Admin"
+};
+
+exports.AND = AND;
+exports.AggregateFunction = AggregateFunction;
+exports.ArrayField = ArrayField;
+exports.BETWEEN = BETWEEN;
+exports.BaseModel = BaseModel;
+exports.BooleanField = BooleanField;
+exports.CONTAINS = CONTAINS;
+exports.COSINE_DISTANCE = COSINE_DISTANCE;
+exports.Client = Client;
+exports.ClientConfig = ClientConfig;
+exports.Column = Column;
+exports.ColumnDataType = ColumnDataType;
+exports.DateField = DateField;
+exports.DateTimeField = DateTimeField;
+exports.DecimalField = DecimalField;
+exports.DoubleField = DoubleField;
+exports.EQ = EQ;
+exports.EQ_COL = EQ_COL;
+exports.EUCLIDEAN_DISTANCE = EUCLIDEAN_DISTANCE;
+exports.EnumField = EnumField;
+exports.Field = Field;
+exports.FilterOperation = FilterOperation;
+exports.FilterWrapper = FilterWrapper;
+exports.ForeignKey = ForeignKey;
+exports.ForeignKeyAction = ForeignKeyAction;
+exports.ForeignKeyField = ForeignKeyField;
+exports.GT = GT;
+exports.GTE = GTE;
+exports.GTE_COL = GTE_COL;
+exports.GT_COL = GT_COL;
+exports.IN = IN;
+exports.IS_NOT_NULL = IS_NOT_NULL;
+exports.IS_NULL = IS_NULL;
+exports.I_LIKE = I_LIKE;
+exports.IntegerField = IntegerField;
+exports.JsonField = JsonField;
+exports.LIKE = LIKE;
+exports.LT = LT;
+exports.LTE = LTE;
+exports.LTE_COL = LTE_COL;
+exports.LT_COL = LT_COL;
+exports.MoneyField = MoneyField;
+exports.NE = NE;
+exports.NEGATIVE_INNER_PRODUCT = NEGATIVE_INNER_PRODUCT;
+exports.NE_COL = NE_COL;
+exports.NOT_IN = NOT_IN;
+exports.NOT_I_LIKE = NOT_I_LIKE;
+exports.NOT_LIKE = NOT_LIKE;
+exports.OR = OR;
+exports.OVERLAP = OVERLAP;
+exports.SIMILARITY = SIMILARITY;
+exports.SIMILARITY_DISTANCE = SIMILARITY_DISTANCE;
+exports.STRICT_WORD_SIMILARITY = STRICT_WORD_SIMILARITY;
+exports.STRICT_WORD_SIMILARITY_DISTANCE = STRICT_WORD_SIMILARITY_DISTANCE;
+exports.SortType = SortType;
+exports.StringField = StringField;
+exports.SyntropixClient = SyntropixClient;
+exports.SyntropixDBAccessType = SyntropixDBAccessType;
+exports.TextField = TextField;
+exports.TimestampField = TimestampField;
+exports.UuidField = UuidField;
+exports.Value = Value;
+exports.VectorField = VectorField;
+exports.WORD_SIMILARITY = WORD_SIMILARITY;
+exports.WORD_SIMILARITY_DISTANCE = WORD_SIMILARITY_DISTANCE;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map