@syntropix/database 0.1.1 → 0.2.1

package/dist/index.cjs

@@ -1,7 +1,8 @@
 'use strict';
 
-var axios = require('axios');
 require('reflect-metadata');
+var axios = require('axios');
+var bson = require('bson');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -9,9 +10,87 @@ var axios__default = /*#__PURE__*/_interopDefault(axios);
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var Client = class {
+
+// src/types/model/db-index.ts
+var IndexType = {
+  Gin: "Gin",
+  GinTrgmOps: "GinTrgmOps",
+  IvfflatL2Ops: "IvfflatL2Ops",
+  InfflatCosineOps: "InfflatCosineOps",
+  InfflatIpOps: "InfflatIpOps"
+};
+
+// src/types/model/filter.ts
+var SortType = {
+  Descending: "Descending",
+  Ascending: "Ascending"
+};
+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;
+})({});
+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;
+})({});
+
+// src/types/model/foreign-key.ts
+var ForeignKeyAction = {
+  Cascade: "Cascade",
+  Restrict: "Restrict",
+  SetNull: "SetNull",
+  NoAction: "NoAction",
+  SetDefault: "SetDefault"
+};
+
+// src/types/model/shared.ts
+var AccessType = {
+  None: "None",
+  Read: "Read",
+  Write: "Write",
+  Admin: "Admin"
+};
+function handleError(error) {
+  const axiosErr = error;
+  if (axiosErr.response?.data?.status === "error") {
+    throw new Error(axiosErr.response.data.message);
+  }
+  throw new Error(axiosErr.message);
+}
+__name(handleError, "handleError");
+var BaseClient = class {
   static {
-    __name(this, "Client");
+    __name(this, "BaseClient");
   }
   config;
   constructor(config) {
@@ -30,23 +109,41 @@ var Client = class {
     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}`);
+    try {
+      const response = await axios__default.default.get(this.url(path), {
+        headers: this.headers(),
+        params: data
+      });
+      const content = bson.EJSON.parse(JSON.stringify(response.data));
+      if (content.status !== "success") {
+        throw new Error(content.message);
+      }
+      return content.data;
+    } catch (error) {
+      if (axios__default.default.isAxiosError(error)) {
+        handleError(error);
+      }
+      console.error(error);
+      throw new Error("Failed to get data: Unknown error");
     }
-    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}`);
+    try {
+      const response = await axios__default.default.post(this.url(path), data, {
+        headers: this.headers()
+      });
+      const content = bson.EJSON.parse(JSON.stringify(response.data));
+      if (content.status !== "success") {
+        throw new Error(content.message);
+      }
+      return content.data;
+    } catch (error) {
+      if (axios__default.default.isAxiosError(error)) {
+        handleError(error);
+      }
+      console.error(error);
+      throw new Error("Failed to post data: Unknown error");
     }
-    return response.data;
   }
 };
 
@@ -79,210 +176,176 @@ var ClientConfig = class {
   }
 };
 
-// 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;
-})({});
+// src/core/filter-builder.ts
 var AND = /* @__PURE__ */ __name((...conditions) => conditions, "AND");
 var OR = /* @__PURE__ */ __name((...conditions) => conditions, "OR");
 var EQ = /* @__PURE__ */ __name((field, value) => ({
-  column: field,
-  operator: "EQ",
+  columnName: field,
+  operator: FilterOperation.EQ,
   staticValue: value
 }), "EQ");
 var NE = /* @__PURE__ */ __name((field, value) => ({
-  column: field,
-  operator: "NEQ",
+  columnName: field,
+  operator: FilterOperation.NEQ,
   staticValue: value
 }), "NE");
 var GT = /* @__PURE__ */ __name((field, value) => ({
-  column: field,
-  operator: "GT",
+  columnName: field,
+  operator: FilterOperation.GT,
   staticValue: value
 }), "GT");
 var GTE = /* @__PURE__ */ __name((field, value) => ({
-  column: field,
-  operator: "GTE",
+  columnName: field,
+  operator: FilterOperation.GTE,
   staticValue: value
 }), "GTE");
 var LT = /* @__PURE__ */ __name((field, value) => ({
-  column: field,
-  operator: "LT",
+  columnName: field,
+  operator: FilterOperation.LT,
   staticValue: value
 }), "LT");
 var LTE = /* @__PURE__ */ __name((field, value) => ({
-  column: field,
-  operator: "LTE",
+  columnName: field,
+  operator: FilterOperation.LTE,
   staticValue: value
 }), "LTE");
 var IN = /* @__PURE__ */ __name((field, values) => ({
-  column: field,
-  operator: "In",
+  columnName: field,
+  operator: FilterOperation.In,
   staticValue: values
 }), "IN");
 var CONTAINS = /* @__PURE__ */ __name((field, value) => ({
-  column: field,
-  operator: "Contains",
+  columnName: field,
+  operator: FilterOperation.Contains,
   staticValue: value
 }), "CONTAINS");
 var OVERLAP = /* @__PURE__ */ __name((field, value) => ({
-  column: field,
-  operator: "Overlap",
+  columnName: field,
+  operator: FilterOperation.Overlap,
   staticValue: value
 }), "OVERLAP");
 var I_LIKE = /* @__PURE__ */ __name((field, pattern) => ({
-  column: field,
-  operator: "ILike",
+  columnName: field,
+  operator: FilterOperation.ILike,
   staticValue: pattern
 }), "I_LIKE");
 var NOT_I_LIKE = /* @__PURE__ */ __name((field, pattern) => ({
-  column: field,
-  operator: "NotILike",
+  columnName: field,
+  operator: FilterOperation.NotILike,
   staticValue: pattern
 }), "NOT_I_LIKE");
 var NOT_IN = /* @__PURE__ */ __name((field, values) => ({
-  column: field,
-  operator: "NotIn",
+  columnName: field,
+  operator: FilterOperation.NotIn,
   staticValue: values
 }), "NOT_IN");
 var LIKE = /* @__PURE__ */ __name((field, pattern) => ({
-  column: field,
-  operator: "Like",
+  columnName: field,
+  operator: FilterOperation.Like,
   staticValue: pattern
 }), "LIKE");
 var NOT_LIKE = /* @__PURE__ */ __name((field, pattern) => ({
-  column: field,
-  operator: "NotLike",
+  columnName: field,
+  operator: FilterOperation.NotLike,
   staticValue: pattern
 }), "NOT_LIKE");
 var IS_NULL = /* @__PURE__ */ __name((field) => ({
-  column: field,
-  operator: "IsNull"
+  columnName: field,
+  operator: FilterOperation.IsNull
 }), "IS_NULL");
 var IS_NOT_NULL = /* @__PURE__ */ __name((field) => ({
-  column: field,
-  operator: "IsNotNull"
+  columnName: field,
+  operator: FilterOperation.IsNotNull
 }), "IS_NOT_NULL");
 var BETWEEN = /* @__PURE__ */ __name((field, min, max) => ({
-  column: field,
-  operator: "Between",
+  columnName: field,
+  operator: FilterOperation.Between,
   staticValue: [
     min,
     max
   ]
 }), "BETWEEN");
 var EQ_COL = /* @__PURE__ */ __name((field, otherField) => ({
-  column: field,
-  operator: "EQ",
+  columnName: field,
+  operator: FilterOperation.EQ,
   columnValue: otherField
 }), "EQ_COL");
 var NE_COL = /* @__PURE__ */ __name((field, otherField) => ({
-  column: field,
-  operator: "NEQ",
+  columnName: field,
+  operator: FilterOperation.NEQ,
   columnValue: otherField
 }), "NE_COL");
 var GT_COL = /* @__PURE__ */ __name((field, otherField) => ({
-  column: field,
-  operator: "GT",
+  columnName: field,
+  operator: FilterOperation.GT,
   columnValue: otherField
 }), "GT_COL");
 var GTE_COL = /* @__PURE__ */ __name((field, otherField) => ({
-  column: field,
-  operator: "GTE",
+  columnName: field,
+  operator: FilterOperation.GTE,
   columnValue: otherField
 }), "GTE_COL");
 var LT_COL = /* @__PURE__ */ __name((field, otherField) => ({
-  column: field,
-  operator: "LT",
+  columnName: field,
+  operator: FilterOperation.LT,
   columnValue: otherField
 }), "LT_COL");
 var LTE_COL = /* @__PURE__ */ __name((field, otherField) => ({
-  column: field,
-  operator: "LTE",
+  columnName: field,
+  operator: FilterOperation.LTE,
   columnValue: otherField
 }), "LTE_COL");
 var SIMILARITY = /* @__PURE__ */ __name((field, value, options) => ({
-  column: field,
-  operator: "Similarity",
+  columnName: field,
+  operator: FilterOperation.Similarity,
   staticValue: value,
   simiarityOptions: options
 }), "SIMILARITY");
 var SIMILARITY_DISTANCE = /* @__PURE__ */ __name((field, value, options) => ({
-  column: field,
-  operator: "SimilarityDistance",
+  columnName: field,
+  operator: FilterOperation.SimilarityDistance,
   staticValue: value,
   simiarityOptions: options
 }), "SIMILARITY_DISTANCE");
 var WORD_SIMILARITY = /* @__PURE__ */ __name((field, value, options) => ({
-  column: field,
-  operator: "WordSimilarity",
+  columnName: field,
+  operator: FilterOperation.WordSimilarity,
   staticValue: value,
   simiarityOptions: options
 }), "WORD_SIMILARITY");
 var WORD_SIMILARITY_DISTANCE = /* @__PURE__ */ __name((field, value, options) => ({
-  column: field,
-  operator: "WordSimilarityDistance",
+  columnName: field,
+  operator: FilterOperation.WordSimilarityDistance,
   staticValue: value,
   simiarityOptions: options
 }), "WORD_SIMILARITY_DISTANCE");
 var STRICT_WORD_SIMILARITY = /* @__PURE__ */ __name((field, value, options) => ({
-  column: field,
-  operator: "StrictWordSimilarity",
+  columnName: field,
+  operator: FilterOperation.StrictWordSimilarity,
   staticValue: value,
   simiarityOptions: options
 }), "STRICT_WORD_SIMILARITY");
 var STRICT_WORD_SIMILARITY_DISTANCE = /* @__PURE__ */ __name((field, value, options) => ({
-  column: field,
-  operator: "StrictWordSimilarityDistance",
+  columnName: field,
+  operator: FilterOperation.StrictWordSimilarityDistance,
   staticValue: value,
   simiarityOptions: options
 }), "STRICT_WORD_SIMILARITY_DISTANCE");
 var EUCLIDEAN_DISTANCE = /* @__PURE__ */ __name((field, value, options) => ({
-  column: field,
-  operator: "EuclideanDistance",
+  columnName: field,
+  operator: FilterOperation.EuclideanDistance,
   staticValue: value,
   simiarityOptions: options
 }), "EUCLIDEAN_DISTANCE");
 var NEGATIVE_INNER_PRODUCT = /* @__PURE__ */ __name((field, value, options) => ({
-  column: field,
-  operator: "NegativeInnerProduct",
+  columnName: field,
+  operator: FilterOperation.NegativeInnerProduct,
   staticValue: value,
   simiarityOptions: options
 }), "NEGATIVE_INNER_PRODUCT");
 var COSINE_DISTANCE = /* @__PURE__ */ __name((field, value, options) => ({
-  column: field,
-  operator: "CosineDistance",
+  columnName: field,
+  operator: FilterOperation.CosineDistance,
   staticValue: value,
   simiarityOptions: options
 }), "COSINE_DISTANCE");
@@ -301,155 +364,91 @@ function FilterWrapper(filter) {
 }
 __name(FilterWrapper, "FilterWrapper");
 
-// src/core/data-client.ts
+// src/core/client/data-client.ts
 var DataClient = class {
   static {
     __name(this, "DataClient");
   }
   client;
   constructor(config = new ClientConfig()) {
-    this.client = new Client(config);
+    this.client = new BaseClient(config);
   }
   async insertData(data) {
-    const response = await this.client.post("/insert", data);
-    if (response.status === "success") {
-      return response.data;
-    }
-    throw new Error(response.message);
+    return await this.client.post("/insert", data);
   }
   async insertOne(data) {
-    const response = await this.client.post("/insert/one", data);
-    if (response.status === "success") {
-      return response.data;
-    }
-    throw new Error(response.message);
+    return await this.client.post("/insert/one", data);
   }
   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);
+    return await this.client.post(`/update/${pk}`, data);
   }
   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;
+    if (model !== void 0) {
+      return new model(response);
     }
-    throw new Error(response.message);
+    return response;
   }
   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;
+    if (model !== void 0) {
+      return response.map((item) => new model(item));
     }
-    throw new Error(response.message);
+    return response;
   }
   async updateData(data) {
-    const response = await this.client.post("/update", data);
-    if (response.status === "success") {
-      return response.data;
-    }
-    throw new Error(response.message);
+    return await this.client.post("/update", data);
   }
   async deleteData(data) {
-    const response = await this.client.post("/delete", data);
-    if (response.status === "success") {
-      return response.data;
-    }
-    throw new Error(response.message);
+    return await this.client.post("/delete", data);
   }
 };
 
-// src/core/table-client.ts
+// src/core/client/table-client.ts
 var TableClient = class {
   static {
     __name(this, "TableClient");
   }
   client;
   constructor(config = new ClientConfig()) {
-    this.client = new Client(config);
+    this.client = new BaseClient(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);
+    return await this.client.post("/table/create", data);
   }
   async dropTable(data) {
-    const response = await this.client.post("/table/drop", data);
-    if (response.status === "success") {
-      return response.data;
-    }
-    throw new Error(response.message);
+    return await this.client.post("/table/drop", data);
   }
   async renameTable(data) {
-    const response = await this.client.post("/table/rename", data);
-    if (response.status === "success") {
-      return response.data;
-    }
-    throw new Error(response.message);
+    return await this.client.post("/table/rename", data);
   }
   async truncateTable(data) {
-    const response = await this.client.post("/table/truncate", data);
-    if (response.status === "success") {
-      return response.data;
-    }
-    throw new Error(response.message);
+    return await this.client.post("/table/truncate", data);
   }
   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);
+    return await this.client.post("/table/column/add", data);
   }
   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);
+    return await this.client.post("/table/column/drop", data);
   }
   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);
+    return await this.client.post("/table/column/modify", data);
   }
   async getTableSchema(data) {
-    const response = await this.client.post("/table/schema", data);
-    if (response.status === "success") {
-      return response.data;
-    }
-    throw new Error(response.message);
+    return await this.client.get("/table/schema", data);
   }
   async getTableList(data) {
-    const response = await this.client.get("/table/list", data);
-    if (response.status === "success") {
-      return response.data;
-    }
-    throw new Error(response.message);
+    return await this.client.get("/table/list", data);
   }
 };
 
-// src/core/syntropix.ts
+// src/core/client/syntropix-client.ts
 var SyntropixClient = class {
   static {
     __name(this, "SyntropixClient");
@@ -474,26 +473,40 @@ var SyntropixClient = class {
   }
 };
 
-// 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
+// src/core/data-type.ts
+var ArrayDataType = {
+  String: /* @__PURE__ */ __name((maxLength) => ({
+    String: maxLength
+  }), "String"),
+  Decimal: /* @__PURE__ */ __name((precision, scale) => ({
+    Decimal: precision && scale ? [
+      precision,
+      scale
+    ] : null
+  }), "Decimal"),
+  Text: "Text",
+  Integer: "Integer",
+  BigInteger: "BigInteger",
+  Double: "Double",
+  DateTime: "DateTime",
+  Timestamp: "Timestamp",
+  Date: "Date",
+  Boolean: "Boolean",
+  Money: /* @__PURE__ */ __name((precision, scale) => ({
+    Money: precision && scale ? [
+      precision,
+      scale
+    ] : null
+  }), "Money"),
+  Uuid: "Uuid",
+  Enum: /* @__PURE__ */ __name((name, variants) => ({
+    Enum: {
+      name,
+      variants
+    }
+  }), "Enum"),
+  Json: "Json"
+};
 var ColumnDataType = {
   Integer: "Integer",
   String: /* @__PURE__ */ __name((maxLength) => ({
@@ -533,12 +546,13 @@ var ColumnDataType = {
   }), "Decimal")
 };
 
-// src/types/field.ts
+// src/core/field.ts
 var Field = class {
   static {
     __name(this, "Field");
   }
   name = "";
+  displayName = "";
   description = "";
   columnType;
   isPrimaryKey = false;
@@ -549,6 +563,7 @@ var Field = class {
   constructor(columnType, options = {}) {
     this.columnType = columnType;
     this.name = options.name?.toLowerCase() || "";
+    this.displayName = options.displayName || "";
     this.description = options.description || "";
     this.isPrimaryKey = options.isPrimaryKey || false;
     this.isNullable = options.isNullable || false;
@@ -556,9 +571,10 @@ var Field = class {
     this.default = options.default;
     this.defaultAccess = options.defaultAccess;
   }
-  into() {
+  intoColumnCreateDto() {
     return {
       name: this.name,
+      displayName: this.displayName,
       columnType: this.columnType,
       description: this.description,
       isPrimaryKey: this.isPrimaryKey,
@@ -705,8 +721,11 @@ var DoubleField = class extends Field {
     super(ColumnDataType.Double, options);
   }
 };
+
+// src/core/base-model.ts
 var FIELDS_KEY = Symbol("fields");
 var TABLE_NAME_KEY = Symbol("tableName");
+var TABLE_DISPLAY_NAME_KEY = Symbol("displayTableName");
 var DESCRIPTION_KEY = Symbol("description");
 var INDEXES_KEY = Symbol("indexes");
 function Column(options = {}) {
@@ -718,11 +737,13 @@ function Column(options = {}) {
       constructor() {
         super(columnType, {
           name: fieldName,
+          displayName: options.displayName,
           description: options.description,
           isPrimaryKey: options.primary,
           isNullable: options.nullable,
           autoIncrement: options.autoIncrement,
-          default: options.default
+          default: options.default,
+          defaultAccess: options.defaultAccess
         });
       }
     }();
@@ -731,15 +752,22 @@ function Column(options = {}) {
   };
 }
 __name(Column, "Column");
+function Description(description) {
+  return function(target) {
+    Reflect.defineMetadata(DESCRIPTION_KEY, description, target);
+  };
+}
+__name(Description, "Description");
 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,
+      displayName: options.displayName,
       description: options.description,
       isNullable: options.nullable,
-      default: options.default
+      default: options.default,
+      onDelete: options.onDelete,
+      onUpdate: options.onUpdate
     });
     field.name = options.name || propertyKey.toLowerCase();
     fields[propertyKey] = field;
@@ -778,6 +806,14 @@ var BaseModel = class {
     }
     return this.name.toLowerCase();
   }
+  static getDisplayName() {
+    const displayName = Reflect.getMetadata(TABLE_DISPLAY_NAME_KEY, this);
+    if (displayName) return displayName;
+    if ("displayName" in this && typeof this.displayName === "string") {
+      return this.displayName;
+    }
+    return this.name;
+  }
   static getDescription() {
     const metadataDescription = Reflect.getMetadata(DESCRIPTION_KEY, this);
     if (metadataDescription) return metadataDescription;
@@ -830,6 +866,9 @@ var BaseModel = class {
   getTableName() {
     return this.constructor.getTableName();
   }
+  getDisplayName() {
+    return this.constructor.getDisplayName();
+  }
   getPrimaryKeyName() {
     return this.constructor.getPrimaryKeyName();
   }
@@ -845,14 +884,14 @@ var BaseModel = class {
   // Client getter
   get client() {
     if (!this._client) {
-      this._client = new SyntropixClient(new ClientConfig());
+      this._client = new SyntropixClient();
     }
     return this._client;
   }
   // Table operations
-  static async createTable(_client) {
+  static async createTable(client = new SyntropixClient()) {
     const fields = this.getFields();
-    const columns = Object.values(fields).map((f) => f.into());
+    const columns = Object.values(fields).map((f) => f.intoColumnCreateDto());
     const foreignKeys = this.getAssociations().map((f) => ({
       fromTableName: this.getTableName(),
       fromColumnName: f.name,
@@ -862,36 +901,38 @@ var BaseModel = class {
       onUpdate: f.onUpdate
     }));
     const indexes = this.getIndexes();
-    const client = _client || new SyntropixClient(new ClientConfig());
-    return client.table.createTable({
+    return await client.table.createTable({
       name: this.getTableName(),
+      displayName: this.getDisplayName(),
       description: this.getDescription() || "No description",
       columns,
       foreignKeys,
       indexes
     });
   }
-  static async dropTable(_client) {
-    const client = _client || new SyntropixClient(new ClientConfig());
-    return client.table.dropTable({
+  static async dropTable(client = new SyntropixClient()) {
+    return await client.table.dropTable({
       tableName: this.getTableName()
     });
   }
-  static async renameTable(newName, _client) {
-    const client = _client || new SyntropixClient(new ClientConfig());
-    return client.table.renameTable({
+  static async renameTable(newName, client = new SyntropixClient()) {
+    return await client.table.renameTable({
       tableName: this.getTableName(),
       newTableName: newName
     });
   }
-  static async truncateTable(_client) {
-    const client = _client || new SyntropixClient(new ClientConfig());
-    return client.table.truncateTable({
+  static async truncateTable(client = new SyntropixClient()) {
+    return await client.table.truncateTable({
+      tableName: this.getTableName()
+    });
+  }
+  static async getTableSchema(client = new SyntropixClient()) {
+    return await client.table.getTableSchema({
       tableName: this.getTableName()
     });
   }
   // Data operations
-  static async create(data, _client) {
+  static async create(data, client = new SyntropixClient()) {
     const model = this;
     const fields = model.getFields();
     const columns = [];
@@ -904,7 +945,6 @@ var BaseModel = class {
         throw new Error(`Invalid field: ${key}`);
       }
     }
-    const client = _client || new SyntropixClient(new ClientConfig());
     return client.data.insertOne({
       tableName: model.getTableName(),
       data: {
@@ -915,7 +955,7 @@ var BaseModel = class {
       }
     });
   }
-  async save(_client) {
+  async save(client = new SyntropixClient()) {
     const pk = this.getPrimaryKey();
     const pkValue = this[this.getPrimaryKeyName()];
     const fields = this.getFields();
@@ -924,7 +964,7 @@ var BaseModel = class {
       for (const [key, field] of Object.entries(fields)) {
         data[key] = this[key];
       }
-      return this.constructor.create(data, _client);
+      return this.constructor.create(data, client);
     }
     const columns = [];
     const values = [];
@@ -934,7 +974,7 @@ var BaseModel = class {
         values.push(this[key]);
       }
     }
-    return _client || this.client.data.updateByPrimaryKey(pkValue, {
+    return client || this.client.data.updateByPrimaryKey(pkValue, {
       tableName: this.getTableName(),
       payload: {
         filter: [
@@ -971,7 +1011,7 @@ var BaseModel = class {
       }
     }
     let values = [];
-    const client = _client || new SyntropixClient(new ClientConfig());
+    const client = _client || new SyntropixClient();
     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");
@@ -1012,7 +1052,7 @@ var BaseModel = class {
       }
     }
     const values = columns.map((c) => data[c]);
-    const client = _client || new SyntropixClient(new ClientConfig());
+    const client = _client || new SyntropixClient();
     return client.data.updateData({
       tableName: model.getTableName(),
       payload: {
@@ -1024,7 +1064,7 @@ var BaseModel = class {
   }
   static async delete(filter, _client) {
     const model = this;
-    const client = _client || new SyntropixClient(new ClientConfig());
+    const client = _client || new SyntropixClient();
     return client.data.deleteData({
       tableName: model.getTableName(),
       payload: {
@@ -1035,7 +1075,7 @@ var BaseModel = class {
   static async get(filter, select, _client) {
     const model = this;
     const fields = model.getFields();
-    const client = _client || new SyntropixClient(new ClientConfig());
+    const client = _client || new SyntropixClient();
     const data = await client.data.queryOne({
       tableName: model.getTableName(),
       query: {
@@ -1048,7 +1088,7 @@ var BaseModel = class {
   }
   static async filter(options) {
     const model = this;
-    const client = options._client || new SyntropixClient(new ClientConfig());
+    const client = options._client || new SyntropixClient();
     const data = await client.data.queryMany({
       tableName: model.getTableName(),
       query: {
@@ -1068,7 +1108,7 @@ var BaseModel = class {
   }
   static async count(options = {}) {
     const model = this;
-    const client = options._client || new SyntropixClient(new ClientConfig());
+    const client = options._client || new SyntropixClient();
     const data = await client.data.queryMany({
       tableName: model.getTableName(),
       query: {
@@ -1122,29 +1162,25 @@ var BaseModel = class {
   }
 };
 
-// src/types/requests.ts
-var SyntropixDBAccessType = {
-  None: "None",
-  Read: "Read",
-  Write: "Write",
-  Admin: "Admin"
-};
-
 exports.AND = AND;
+exports.AccessType = AccessType;
 exports.AggregateFunction = AggregateFunction;
+exports.ArrayDataType = ArrayDataType;
 exports.ArrayField = ArrayField;
 exports.BETWEEN = BETWEEN;
+exports.BaseClient = BaseClient;
 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.DataClient = DataClient;
 exports.DateField = DateField;
 exports.DateTimeField = DateTimeField;
 exports.DecimalField = DecimalField;
+exports.Description = Description;
 exports.DoubleField = DoubleField;
 exports.EQ = EQ;
 exports.EQ_COL = EQ_COL;
@@ -1164,6 +1200,7 @@ exports.IN = IN;
 exports.IS_NOT_NULL = IS_NOT_NULL;
 exports.IS_NULL = IS_NULL;
 exports.I_LIKE = I_LIKE;
+exports.IndexType = IndexType;
 exports.IntegerField = IntegerField;
 exports.JsonField = JsonField;
 exports.LIKE = LIKE;
@@ -1187,7 +1224,7 @@ exports.STRICT_WORD_SIMILARITY_DISTANCE = STRICT_WORD_SIMILARITY_DISTANCE;
 exports.SortType = SortType;
 exports.StringField = StringField;
 exports.SyntropixClient = SyntropixClient;
-exports.SyntropixDBAccessType = SyntropixDBAccessType;
+exports.TableClient = TableClient;
 exports.TextField = TextField;
 exports.TimestampField = TimestampField;
 exports.UuidField = UuidField;