@promakeai/orm 1.0.5 → 1.3.0

package/dist/index.js

@@ -344,8 +344,13 @@ function getRefTargetFull(field) {
   }
   return { table: field.ref.table, field: field.ref.field || "id" };
 }
+function getTablePermissions(table) {
+  return table.permissions;
+}
 
 // src/schema/validator.ts
+var VALID_ROLES = ["anon", "user", "admin"];
+var VALID_ACTIONS = ["create", "read", "update", "delete"];
 var ValidationErrorCode = {
   MISSING_PRIMARY_KEY: "MISSING_PRIMARY_KEY",
   INVALID_REFERENCE: "INVALID_REFERENCE",
@@ -353,7 +358,9 @@ var ValidationErrorCode = {
   NO_LANGUAGES: "NO_LANGUAGES",
   DUPLICATE_TABLE: "DUPLICATE_TABLE",
   RESERVED_FIELD_NAME: "RESERVED_FIELD_NAME",
-  SELF_REFERENCE_ON_REQUIRED: "SELF_REFERENCE_ON_REQUIRED"
+  SELF_REFERENCE_ON_REQUIRED: "SELF_REFERENCE_ON_REQUIRED",
+  INVALID_PERMISSION_ROLE: "INVALID_PERMISSION_ROLE",
+  INVALID_PERMISSION_ACTION: "INVALID_PERMISSION_ACTION"
 };
 var RESERVED_FIELDS = ["language_code"];
 function validateSchema(schema) {
@@ -412,6 +419,30 @@ function validateSchema(schema) {
         });
       }
     }
+    if (table.permissions) {
+      for (const [role, actions] of Object.entries(table.permissions)) {
+        if (!VALID_ROLES.includes(role)) {
+          errors.push({
+            table: tableName,
+            field: "$permissions",
+            message: `Invalid permission role: "${role}". Valid roles: ${VALID_ROLES.join(", ")}`,
+            code: ValidationErrorCode.INVALID_PERMISSION_ROLE
+          });
+        }
+        if (Array.isArray(actions)) {
+          for (const action of actions) {
+            if (!VALID_ACTIONS.includes(action)) {
+              errors.push({
+                table: tableName,
+                field: "$permissions",
+                message: `Invalid permission action: "${action}". Valid actions: ${VALID_ACTIONS.join(", ")}`,
+                code: ValidationErrorCode.INVALID_PERMISSION_ACTION
+              });
+            }
+          }
+        }
+      }
+    }
   }
   return errors;
 }
@@ -458,191 +489,6 @@ function validateTable(tableName, table, allTableNames) {
   }
   return errors;
 }
-
-// src/schema/fieldBuilder.ts
-class FieldBuilder {
-  definition;
-  constructor(type) {
-    this.definition = {
-      type,
-      nullable: true,
-      unique: false,
-      primary: false,
-      translatable: false
-    };
-  }
-  required() {
-    this.definition.nullable = false;
-    return this;
-  }
-  nullable() {
-    this.definition.nullable = true;
-    return this;
-  }
-  unique() {
-    this.definition.unique = true;
-    return this;
-  }
-  default(value) {
-    this.definition.default = value;
-    return this;
-  }
-  translatable() {
-    this.definition.translatable = true;
-    return this;
-  }
-  ref(tableOrOptions) {
-    this.definition.ref = tableOrOptions;
-    return this;
-  }
-  trim() {
-    this.definition.trim = true;
-    return this;
-  }
-  lowercase() {
-    this.definition.lowercase = true;
-    return this;
-  }
-  uppercase() {
-    this.definition.uppercase = true;
-    return this;
-  }
-  minLength(value) {
-    this.definition.minLength = value;
-    return this;
-  }
-  maxLength(value) {
-    this.definition.maxLength = value;
-    return this;
-  }
-  min(value) {
-    this.definition.min = value;
-    return this;
-  }
-  max(value) {
-    this.definition.max = value;
-    return this;
-  }
-  enum(values) {
-    this.definition.enum = values;
-    return this;
-  }
-  match(pattern) {
-    this.definition.match = pattern;
-    return this;
-  }
-  build() {
-    return { ...this.definition };
-  }
-}
-var f = {
-  id: () => {
-    const builder = new FieldBuilder("id");
-    builder["definition"].primary = true;
-    builder["definition"].nullable = false;
-    return builder;
-  },
-  string: () => new FieldBuilder("string"),
-  text: () => new FieldBuilder("text"),
-  int: () => new FieldBuilder("int"),
-  decimal: () => new FieldBuilder("decimal"),
-  bool: () => new FieldBuilder("bool"),
-  timestamp: () => new FieldBuilder("timestamp"),
-  json: () => new FieldBuilder("json"),
-  stringArray: () => new FieldBuilder("string[]"),
-  numberArray: () => new FieldBuilder("number[]"),
-  boolArray: () => new FieldBuilder("boolean[]"),
-  object: (properties) => {
-    const builder = new FieldBuilder("object");
-    builder["definition"].properties = properties;
-    return builder;
-  },
-  objectArray: (properties) => {
-    const builder = new FieldBuilder("object[]");
-    builder["definition"].properties = properties;
-    return builder;
-  }
-};
-
-// src/schema/defineSchema.ts
-function defineSchema(input) {
-  const languages = normalizeLanguages(input.languages);
-  const tables = {};
-  for (const [tableName, fields] of Object.entries(input.tables)) {
-    tables[tableName] = {
-      name: tableName,
-      fields: Object.fromEntries(Object.entries(fields).map(([fieldName, builder]) => [
-        fieldName,
-        builder.build()
-      ]))
-    };
-  }
-  const schema = {
-    name: input.name,
-    languages,
-    tables
-  };
-  assertValidSchema(schema);
-  return schema;
-}
-function normalizeLanguages(input) {
-  if (Array.isArray(input)) {
-    if (input.length === 0) {
-      throw new Error("At least one language must be defined");
-    }
-    return {
-      default: input[0],
-      supported: input
-    };
-  }
-  return input;
-}
-function createSchemaUnsafe(input) {
-  const languages = normalizeLanguages(input.languages);
-  const tables = {};
-  for (const [tableName, fields] of Object.entries(input.tables)) {
-    tables[tableName] = {
-      name: tableName,
-      fields: Object.fromEntries(Object.entries(fields).map(([fieldName, builder]) => [
-        fieldName,
-        builder.build()
-      ]))
-    };
-  }
-  return {
-    name: input.name,
-    languages,
-    tables
-  };
-}
-function mergeSchemas(schemas) {
-  if (schemas.length === 0) {
-    throw new Error("At least one schema is required");
-  }
-  const defaultLang = schemas[0].languages.default;
-  const allLangs = new Set;
-  for (const schema of schemas) {
-    for (const lang of schema.languages.supported) {
-      allLangs.add(lang);
-    }
-  }
-  const tables = {};
-  for (const schema of schemas) {
-    for (const [tableName, table] of Object.entries(schema.tables)) {
-      if (tables[tableName]) {
-        throw new Error(`Duplicate table name across schemas: ${tableName}`);
-      }
-      tables[tableName] = table;
-    }
-  }
-  return {
-    languages: {
-      default: defaultLang,
-      supported: Array.from(allLangs)
-    },
-    tables
-  };
-}
 // src/schema/helpers.ts
 function singularize(word) {
   const irregulars = {
@@ -722,6 +568,338 @@ function toTranslationTableName(tableName) {
 function toTranslationFKName(tableName) {
   return `${singularize(tableName)}_id`;
 }
+// src/adapters/RestAdapter.ts
+class RestAdapter {
+  baseUrl;
+  databasePrefix;
+  token;
+  getTokenFn;
+  customHeaders;
+  fetchFn;
+  timeout;
+  schema;
+  defaultLang;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/+$/, "");
+    this.databasePrefix = config.databasePrefix ?? "/database";
+    this.token = config.token;
+    this.getTokenFn = config.getToken;
+    this.customHeaders = config.headers ?? {};
+    const gf = globalThis;
+    this.fetchFn = config.fetch ?? gf.fetch.bind(gf);
+    this.timeout = config.timeout ?? 30000;
+    this.schema = config.schema;
+    this.defaultLang = config.defaultLang;
+  }
+  buildUrl(path) {
+    return `${this.baseUrl}${this.databasePrefix}${path}`;
+  }
+  getHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      ...this.customHeaders
+    };
+    const token = this.getTokenFn ? this.getTokenFn() : this.token;
+    if (token) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+    return headers;
+  }
+  async request(url, init) {
+    const controller = new AbortController;
+    const timer = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await this.fetchFn(url, {
+        ...init,
+        headers: { ...this.getHeaders(), ...init?.headers ?? {} },
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        const body = await response.json().catch(() => null);
+        const message = body?.message || body?.error || `HTTP ${response.status} ${response.statusText}`;
+        throw new Error(message);
+      }
+      return await response.json();
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  buildQueryParams(options) {
+    const params = new URLSearchParams;
+    if (!options)
+      return params;
+    if (options.where && Object.keys(options.where).length > 0) {
+      params.set("where", JSON.stringify(options.where));
+    }
+    if (options.orderBy?.length) {
+      params.set("order", options.orderBy.map((o) => `${o.field}:${o.direction}`).join(","));
+    }
+    if (options.limit != null) {
+      params.set("limit", String(options.limit));
+    }
+    if (options.offset != null) {
+      params.set("offset", String(options.offset));
+    }
+    if (options.lang) {
+      params.set("lang", options.lang);
+    }
+    if (options.fallbackLang) {
+      params.set("fallback_lang", options.fallbackLang);
+    }
+    return params;
+  }
+  urlWithParams(base, params) {
+    const qs = params.toString();
+    return qs ? `${base}?${qs}` : base;
+  }
+  setSchema(schema) {
+    this.schema = schema;
+  }
+  async connect() {
+    if (!this.schema)
+      return;
+    const apiSchema = {};
+    for (const [tableName, tableDef] of Object.entries(this.schema.tables)) {
+      const columns = [];
+      for (const [fieldName, fieldDef] of Object.entries(tableDef.fields)) {
+        const col = {
+          name: fieldName,
+          type: this.mapFieldType(fieldDef.type)
+        };
+        if (fieldDef.primary)
+          col.primary_key = true;
+        if (!fieldDef.nullable)
+          col.not_null = true;
+        if (fieldDef.unique)
+          col.unique = true;
+        if (fieldDef.default !== undefined)
+          col.default_value = String(fieldDef.default);
+        if (fieldDef.translatable)
+          col.translatable = true;
+        columns.push(col);
+      }
+      const tableEntry = { columns };
+      if (tableDef.permissions) {
+        tableEntry.permissions = tableDef.permissions;
+      }
+      apiSchema[tableName] = tableEntry;
+    }
+    await this.request(this.buildUrl("/generate"), {
+      method: "POST",
+      body: JSON.stringify({ schema: { tables: apiSchema } })
+    });
+  }
+  mapFieldType(type) {
+    switch (type) {
+      case "id":
+      case "int":
+        return "INTEGER";
+      case "string":
+      case "text":
+      case "timestamp":
+        return "TEXT";
+      case "decimal":
+        return "REAL";
+      case "bool":
+        return "INTEGER";
+      case "json":
+      case "object":
+      case "object[]":
+      case "string[]":
+      case "number[]":
+      case "boolean[]":
+        return "TEXT";
+      default:
+        return "TEXT";
+    }
+  }
+  close() {}
+  async list(table, options) {
+    const params = this.buildQueryParams(options);
+    const url = this.urlWithParams(this.buildUrl(`/${table}/list`), params);
+    const res = await this.request(url);
+    return res.data;
+  }
+  async get(table, id, options) {
+    const params = new URLSearchParams;
+    if (options?.lang)
+      params.set("lang", options.lang);
+    if (options?.fallbackLang)
+      params.set("fallback_lang", options.fallbackLang);
+    const url = this.urlWithParams(this.buildUrl(`/${table}/${id}`), params);
+    try {
+      const res = await this.request(url);
+      return res.data ?? null;
+    } catch (err) {
+      if (err instanceof Error && err.message.includes("404")) {
+        return null;
+      }
+      throw err;
+    }
+  }
+  async findOne(table, options) {
+    const results = await this.list(table, { ...options, limit: 1 });
+    return results[0] ?? null;
+  }
+  async count(table, options) {
+    const params = new URLSearchParams;
+    if (options?.where && Object.keys(options.where).length > 0) {
+      params.set("where", JSON.stringify(options.where));
+    }
+    const url = this.urlWithParams(this.buildUrl(`/${table}/count`), params);
+    const res = await this.request(url);
+    return res.count;
+  }
+  async paginate(table, page, limit, options) {
+    const offset = (page - 1) * limit;
+    const [total, data] = await Promise.all([
+      this.count(table, options),
+      this.list(table, { ...options, limit, offset })
+    ]);
+    const totalPages = Math.ceil(total / limit);
+    return {
+      data,
+      page,
+      limit,
+      total,
+      totalPages,
+      hasMore: page < totalPages
+    };
+  }
+  async create(table, data) {
+    const url = this.buildUrl(`/${table}/create`);
+    const res = await this.request(url, {
+      method: "POST",
+      body: JSON.stringify({ data })
+    });
+    const result = res.data ?? {};
+    if (res.id !== undefined && !("id" in result)) {
+      result.id = res.id;
+    }
+    return result;
+  }
+  async update(table, id, data, options) {
+    const url = this.buildUrl(`/${table}/${id}`);
+    const body = { data };
+    if (options?.translations) {
+      body.translations = options.translations;
+    }
+    const res = await this.request(url, {
+      method: "PUT",
+      body: JSON.stringify(body)
+    });
+    return res.data;
+  }
+  async delete(table, id) {
+    const url = this.buildUrl(`/${table}/${id}`);
+    try {
+      const res = await this.request(url, {
+        method: "DELETE"
+      });
+      return res.deleted ?? true;
+    } catch (err) {
+      if (err instanceof Error && err.message.includes("404")) {
+        return false;
+      }
+      throw err;
+    }
+  }
+  async createMany(table, records, options) {
+    const url = this.buildUrl(`/${table}/create-batch`);
+    const res = await this.request(url, {
+      method: "POST",
+      body: JSON.stringify({
+        records,
+        ignore: options?.ignore ?? false,
+        no_atomic: options?.noAtomic ?? false
+      })
+    });
+    return { created: res.created, ids: res.ids };
+  }
+  async updateMany(table, updates, options) {
+    const url = this.buildUrl(`/${table}/update-batch`);
+    const res = await this.request(url, {
+      method: "POST",
+      body: JSON.stringify({
+        updates,
+        no_atomic: options?.noAtomic ?? false
+      })
+    });
+    return { updated: res.updated };
+  }
+  async deleteMany(table, ids, options) {
+    const url = this.buildUrl(`/${table}/delete-batch`);
+    const res = await this.request(url, {
+      method: "POST",
+      body: JSON.stringify({
+        ids,
+        no_atomic: options?.noAtomic ?? false
+      })
+    });
+    return { deleted: res.deleted };
+  }
+  async createWithTranslations(table, data, translations) {
+    const url = this.buildUrl(`/${table}/create`);
+    const res = await this.request(url, {
+      method: "POST",
+      body: JSON.stringify({ data, translations })
+    });
+    const result = res.data ?? {};
+    if (res.id !== undefined && !("id" in result)) {
+      result.id = res.id;
+    }
+    return result;
+  }
+  async upsertTranslation(table, id, lang, data) {
+    const url = this.buildUrl(`/${table}/${id}`);
+    await this.request(url, {
+      method: "PUT",
+      body: JSON.stringify({ data, lang })
+    });
+  }
+  async getTranslations(table, id) {
+    const translationTable = toTranslationTableName(table);
+    const fkName = toTranslationFKName(table);
+    const params = new URLSearchParams;
+    params.set("where", JSON.stringify({ [fkName]: id }));
+    const url = this.urlWithParams(this.buildUrl(`/${translationTable}/list`), params);
+    const res = await this.request(url);
+    return res.data;
+  }
+  async raw(query, params) {
+    const url = this.buildUrl("/exec");
+    const res = await this.request(url, {
+      method: "POST",
+      body: JSON.stringify({ sql: query, params: params ?? [] })
+    });
+    return res.data;
+  }
+  async execute(query, params) {
+    const url = this.buildUrl("/exec");
+    const res = await this.request(url, {
+      method: "POST",
+      body: JSON.stringify({ sql: query, params: params ?? [] })
+    });
+    return {
+      changes: res.changes,
+      lastInsertRowid: res.last_insert_rowid ?? 0
+    };
+  }
+  async beginTransaction() {}
+  async commit() {}
+  async rollback() {}
+  async getTables() {
+    const url = this.buildUrl("/tables");
+    const res = await this.request(url);
+    return res.tables;
+  }
+  async getTableSchema(table) {
+    const url = this.buildUrl(`/${table}/schema`);
+    const res = await this.request(url);
+    return res.columns;
+  }
+}
 // src/utils/whereBuilder.ts
 var COMPARISON_OPERATORS = {
   $eq: "=",
@@ -1008,28 +1186,97 @@ function extractTranslatableData(data, tableSchema) {
   return { mainData, translatableData };
 }
 // src/utils/jsonConverter.ts
+var LANGUAGE_NAME_TO_CODE = {
+  english: "en",
+  turkish: "tr",
+  german: "de",
+  french: "fr",
+  spanish: "es",
+  russian: "ru",
+  arabic: "ar"
+};
 function parseJSONSchema(json) {
+  return parseJSONSchemaWithWarnings(json).schema;
+}
+function parseJSONSchemaWithWarnings(json) {
+  const warnings = [];
+  const supported = (json.languages || ["en"]).map((lang) => normalizeLangToken(lang));
+  const defaultLanguage = resolveDefaultLanguage(json.defaultLanguage, supported, warnings);
   const languages = {
-    default: json.defaultLanguage || json.languages[0] || "en",
-    supported: json.languages || ["en"]
+    default: defaultLanguage,
+    supported
   };
   const tables = {};
   for (const [tableName, jsonTable] of Object.entries(json.tables)) {
     const fields = {};
+    let permissions;
     for (const [fieldName, jsonField] of Object.entries(jsonTable)) {
+      if (fieldName === "$permissions") {
+        permissions = jsonField;
+        continue;
+      }
       fields[fieldName] = convertJSONField(jsonField);
     }
     tables[tableName] = {
       name: tableName,
-      fields
+      fields,
+      ...permissions ? { permissions } : {}
     };
   }
   return {
-    name: json.name,
-    languages,
-    tables
+    schema: {
+      name: json.name,
+      languages,
+      tables
+    },
+    warnings
   };
 }
+function normalizeLangToken(lang) {
+  return String(lang).trim().toLowerCase();
+}
+function resolveDefaultLanguage(input, supported, warnings) {
+  const fallback = supported[0] || "en";
+  if (!input)
+    return fallback;
+  const normalizedInput = normalizeLangToken(input);
+  const directMatch = supported.find((lang) => normalizeLangToken(lang) === normalizedInput);
+  if (directMatch)
+    return directMatch;
+  const languageNameMatch = resolveLanguageNameToSupportedCode(normalizedInput, supported);
+  if (languageNameMatch) {
+    warnings.push(`Normalized defaultLanguage "${input}" to "${languageNameMatch}".`);
+    return languageNameMatch;
+  }
+  throw new Error(`Invalid defaultLanguage "${input}". Expected one of: ${supported.join(", ")}`);
+}
+function resolveLanguageNameToSupportedCode(normalizedInput, supported) {
+  const mapped = LANGUAGE_NAME_TO_CODE[normalizedInput];
+  if (mapped) {
+    const supportedMatch = supported.find((lang) => normalizeLangToken(lang) === mapped);
+    if (supportedMatch)
+      return supportedMatch;
+  }
+  for (const code of supported) {
+    const languageName = getLanguageDisplayName(code);
+    if (languageName && normalizeLangToken(languageName) === normalizedInput) {
+      return code;
+    }
+  }
+  return null;
+}
+function getLanguageDisplayName(code) {
+  try {
+    if (typeof Intl === "undefined" || !("DisplayNames" in Intl)) {
+      return null;
+    }
+    const displayNames = new Intl.DisplayNames(["en"], { type: "language" });
+    const label = displayNames.of(code);
+    return label || null;
+  } catch {
+    return null;
+  }
+}
 function normalizeJsonType(type) {
   if (Array.isArray(type)) {
     const first = type[0];
@@ -1065,7 +1312,7 @@ function convertJSONField(jsonField) {
     type,
     nullable: jsonField.nullable ?? !jsonField.required,
     unique: jsonField.unique ?? false,
-    primary: jsonField.primary ?? false,
+    primary: jsonField.primary ?? type === "id",
     default: jsonField.default,
     translatable: jsonField.translatable ?? false,
     properties,
@@ -1133,14 +1380,15 @@ export {
   serializeRow,
   resolvePopulate,
   pluralize,
+  parseJSONSchemaWithWarnings,
   parseJSONSchema,
-  mergeSchemas,
   isValidSchema,
   isRequiredField,
   isJsonType,
   hasTranslatableFields,
   getTranslationTableFields,
   getTranslatableFields,
+  getTablePermissions,
   getRequiredFields,
   getReferenceFields,
   getRefTargetFull,
@@ -1150,11 +1398,8 @@ export {
   getNonTranslatableFields,
   getMainTableFields,
   getInsertableFields,
-  f,
   extractTranslatableData,
   deserializeRow,
-  defineSchema,
-  createSchemaUnsafe,
   buildWhereClause,
   buildTranslationUpsert,
   buildTranslationQueryById,
@@ -1162,5 +1407,6 @@ export {
   buildTranslationInsert,
   assertValidSchema,
   ValidationErrorCode,
+  RestAdapter,
   ORM
 };