@promakeai/orm 1.0.0

package/dist/index.js

@@ -0,0 +1,1054 @@
+// src/utils/populateResolver.ts
+function getRefInfo(fieldName, field) {
+  if (!field.ref)
+    return null;
+  const ref = field.ref;
+  const isString = typeof ref === "string";
+  return {
+    table: isString ? ref : ref.table,
+    field: isString ? "id" : ref.field || "id",
+    localField: fieldName,
+    targetField: isString ? "id" : ref.field || "id",
+    isArray: Array.isArray(field.default) || fieldName.endsWith("Ids")
+  };
+}
+function toPopulatedName(fieldName) {
+  if (fieldName.endsWith("Ids")) {
+    return fieldName.slice(0, -3) + "s";
+  }
+  if (fieldName.endsWith("Id")) {
+    return fieldName.slice(0, -2);
+  }
+  if (fieldName.endsWith("_id")) {
+    return fieldName.slice(0, -3);
+  }
+  return fieldName;
+}
+function extractUniqueValues(records, fieldName) {
+  const values = new Set;
+  for (const record of records) {
+    const value = record[fieldName];
+    if (value == null)
+      continue;
+    if (Array.isArray(value)) {
+      for (const v of value) {
+        if (v != null)
+          values.add(v);
+      }
+    } else {
+      values.add(value);
+    }
+  }
+  return Array.from(values);
+}
+function createLookupMap(records, keyField) {
+  const map = new Map;
+  for (const record of records) {
+    const key = record[keyField];
+    if (key != null) {
+      map.set(key, record);
+    }
+  }
+  return map;
+}
+function normalizePopulate(populate) {
+  if (!populate)
+    return [];
+  if (typeof populate === "string") {
+    return populate.split(/\s+/).map((fieldName) => ({ fieldName }));
+  }
+  if (Array.isArray(populate)) {
+    return populate.map((fieldName) => ({ fieldName }));
+  }
+  const entries = [];
+  for (const [fieldName, value] of Object.entries(populate)) {
+    if (value === true) {
+      entries.push({ fieldName });
+    } else if (value && typeof value === "object") {
+      entries.push({ fieldName, options: value });
+    }
+  }
+  return entries;
+}
+async function resolvePopulate(records, table, populate, schema, adapter) {
+  if (!records.length)
+    return records;
+  const populateEntries = normalizePopulate(populate);
+  if (!populateEntries.length)
+    return records;
+  const tableDef = schema.tables[table];
+  if (!tableDef)
+    return records;
+  for (const entry of populateEntries) {
+    const { fieldName, options } = entry;
+    const field = tableDef.fields[fieldName];
+    if (!field)
+      continue;
+    const refInfo = getRefInfo(fieldName, field);
+    if (!refInfo)
+      continue;
+    const fkValues = extractUniqueValues(records, fieldName);
+    if (!fkValues.length)
+      continue;
+    const refRecords = await adapter.findMany(refInfo.table, {
+      where: { [refInfo.targetField]: { $in: fkValues } }
+    });
+    let populatedRefRecords = refRecords;
+    if (options?.populate) {
+      populatedRefRecords = await resolvePopulate(refRecords, refInfo.table, options.populate, schema, adapter);
+    }
+    const lookupMap = createLookupMap(populatedRefRecords, refInfo.targetField);
+    const populatedName = toPopulatedName(fieldName);
+    for (const record of records) {
+      const fkValue = record[fieldName];
+      if (fkValue == null) {
+        record[populatedName] = null;
+        continue;
+      }
+      if (refInfo.isArray && Array.isArray(fkValue)) {
+        record[populatedName] = fkValue.map((v) => lookupMap.get(v)).filter(Boolean);
+      } else {
+        record[populatedName] = lookupMap.get(fkValue) || null;
+      }
+    }
+  }
+  return records;
+}
+function getPopulatableFields(tableDef) {
+  return Object.entries(tableDef.fields).filter(([_, field]) => field.ref != null).map(([name]) => name);
+}
+function validatePopulate(populate, table, schema) {
+  const errors = [];
+  const populateEntries = normalizePopulate(populate);
+  const tableDef = schema.tables[table];
+  if (!tableDef) {
+    errors.push(`Table '${table}' not found in schema`);
+    return { valid: false, errors };
+  }
+  for (const entry of populateEntries) {
+    const { fieldName, options } = entry;
+    const field = tableDef.fields[fieldName];
+    if (!field) {
+      errors.push(`Field '${fieldName}' not found in table '${table}'`);
+      continue;
+    }
+    if (!field.ref) {
+      errors.push(`Field '${fieldName}' in table '${table}' is not a reference field`);
+      continue;
+    }
+    if (options?.populate) {
+      const refInfo = getRefInfo(fieldName, field);
+      if (refInfo) {
+        const nestedValidation = validatePopulate(options.populate, refInfo.table, schema);
+        errors.push(...nestedValidation.errors);
+      }
+    }
+  }
+  return { valid: errors.length === 0, errors };
+}
+
+// src/ORM.ts
+class ORM {
+  adapter;
+  schema;
+  defaultLang;
+  fallbackLang;
+  constructor(adapter, config) {
+    this.adapter = adapter;
+    this.schema = config?.schema;
+    this.defaultLang = config?.defaultLang || "en";
+    this.fallbackLang = config?.fallbackLang;
+  }
+  async list(table, options) {
+    const opts = this.normalizeOptions(options);
+    const { populate, ...queryOpts } = opts;
+    let records = await this.adapter.list(table, queryOpts);
+    if (populate && this.schema) {
+      records = await this.resolvePopulateForRecords(records, table, populate);
+    }
+    return records;
+  }
+  async get(table, id, options) {
+    const opts = this.normalizeOptions(options);
+    const { populate, ...queryOpts } = opts;
+    const record = await this.adapter.get(table, id, queryOpts);
+    if (record && populate && this.schema) {
+      const [populated] = await this.resolvePopulateForRecords([record], table, populate);
+      return populated;
+    }
+    return record;
+  }
+  async count(table, options) {
+    const opts = this.normalizeOptions(options);
+    return this.adapter.count(table, opts);
+  }
+  async paginate(table, page, limit, options) {
+    const opts = this.normalizeOptions(options);
+    return this.adapter.paginate(table, page, limit, opts);
+  }
+  async create(table, data) {
+    if (this.schema) {
+      this.validateData(table, data);
+    }
+    return this.adapter.create(table, data);
+  }
+  async update(table, id, data) {
+    if (this.schema) {
+      this.validateData(table, data, true);
+    }
+    return this.adapter.update(table, id, data);
+  }
+  async delete(table, id) {
+    return this.adapter.delete(table, id);
+  }
+  async createMany(table, records, options) {
+    return this.adapter.createMany(table, records, options);
+  }
+  async updateMany(table, updates) {
+    return this.adapter.updateMany(table, updates);
+  }
+  async deleteMany(table, ids) {
+    return this.adapter.deleteMany(table, ids);
+  }
+  async raw(query, params) {
+    return this.adapter.raw(query, params);
+  }
+  async execute(query, params) {
+    return this.adapter.execute(query, params);
+  }
+  async transaction(callback) {
+    await this.adapter.beginTransaction();
+    try {
+      const result = await callback(this);
+      await this.adapter.commit();
+      return result;
+    } catch (error) {
+      await this.adapter.rollback();
+      throw error;
+    }
+  }
+  async getTables() {
+    if (this.adapter.getTables) {
+      return this.adapter.getTables();
+    }
+    throw new Error("Adapter does not support getTables()");
+  }
+  async getTableSchema(table) {
+    if (this.adapter.getTableSchema) {
+      return this.adapter.getTableSchema(table);
+    }
+    throw new Error("Adapter does not support getTableSchema()");
+  }
+  async close() {
+    return this.adapter.close();
+  }
+  normalizeOptions(options) {
+    return {
+      ...options,
+      lang: options?.lang || this.defaultLang,
+      fallbackLang: options?.fallbackLang || this.fallbackLang
+    };
+  }
+  validateData(table, data, isUpdate = false) {
+    if (!this.schema)
+      return;
+    const tableDef = this.schema.tables[table];
+    if (!tableDef) {
+      throw new Error(`Table "${table}" not found in schema`);
+    }
+  }
+  async resolvePopulateForRecords(records, table, populate) {
+    if (!this.schema)
+      return records;
+    const validation = validatePopulate(populate, table, this.schema);
+    if (!validation.valid) {
+      console.warn("Populate validation warnings:", validation.errors);
+    }
+    const adapterWrapper = {
+      findMany: (t, opts) => {
+        return this.adapter.list(t, opts);
+      }
+    };
+    return resolvePopulate(records, table, populate, this.schema, adapterWrapper);
+  }
+  getAdapter() {
+    return this.adapter;
+  }
+  getSchema() {
+    return this.schema;
+  }
+  setSchema(schema) {
+    this.schema = schema;
+  }
+}
+// src/schema/schemaHelpers.ts
+function getTranslatableFields(table) {
+  return Object.entries(table.fields).filter(([_, field]) => field.translatable).map(([name]) => name);
+}
+function getNonTranslatableFields(table) {
+  return Object.entries(table.fields).filter(([_, field]) => !field.translatable && !field.primary).map(([name]) => name);
+}
+function getInsertableFields(table) {
+  return Object.entries(table.fields).filter(([_, field]) => !field.primary).map(([name]) => name);
+}
+function hasTranslatableFields(table) {
+  return getTranslatableFields(table).length > 0;
+}
+function getPrimaryKeyField(table) {
+  const entry = Object.entries(table.fields).find(([_, field]) => field.primary);
+  return entry ? entry[0] : null;
+}
+function getReferenceFields(table) {
+  return Object.entries(table.fields).filter(([_, field]) => field.ref).map(([name, field]) => {
+    const ref = field.ref;
+    if (typeof ref === "string") {
+      return [name, { table: ref, field: "id" }];
+    }
+    return [name, { ...ref, field: ref.field || "id" }];
+  });
+}
+function getMainTableFields(table) {
+  return Object.entries(table.fields).filter(([_, field]) => !field.translatable);
+}
+function getTranslationTableFields(table) {
+  return Object.entries(table.fields).filter(([_, field]) => field.translatable);
+}
+function isRequiredField(field) {
+  return !field.nullable && field.default === undefined && !field.primary;
+}
+function getRequiredFields(table) {
+  return Object.entries(table.fields).filter(([_, field]) => isRequiredField(field)).map(([name]) => name);
+}
+function getRefTarget(field) {
+  if (!field.ref)
+    return null;
+  return typeof field.ref === "string" ? field.ref : field.ref.table;
+}
+function getRefTargetFull(field) {
+  if (!field.ref)
+    return null;
+  if (typeof field.ref === "string") {
+    return { table: field.ref, field: "id" };
+  }
+  return { table: field.ref.table, field: field.ref.field || "id" };
+}
+
+// src/schema/validator.ts
+var ValidationErrorCode = {
+  MISSING_PRIMARY_KEY: "MISSING_PRIMARY_KEY",
+  INVALID_REFERENCE: "INVALID_REFERENCE",
+  INVALID_TRANSLATABLE_TYPE: "INVALID_TRANSLATABLE_TYPE",
+  NO_LANGUAGES: "NO_LANGUAGES",
+  DUPLICATE_TABLE: "DUPLICATE_TABLE",
+  RESERVED_FIELD_NAME: "RESERVED_FIELD_NAME",
+  SELF_REFERENCE_ON_REQUIRED: "SELF_REFERENCE_ON_REQUIRED"
+};
+var RESERVED_FIELDS = ["language_code"];
+function validateSchema(schema) {
+  const errors = [];
+  const tableNames = Object.keys(schema.tables);
+  if (!schema.languages.supported || schema.languages.supported.length === 0) {
+    errors.push({
+      table: "_schema",
+      message: "At least one language must be defined",
+      code: ValidationErrorCode.NO_LANGUAGES
+    });
+  }
+  for (const [tableName, table] of Object.entries(schema.tables)) {
+    const hasPrimaryKey = Object.values(table.fields).some((field) => field.primary);
+    if (!hasPrimaryKey) {
+      errors.push({
+        table: tableName,
+        message: "Table must have a primary key (use f.id())",
+        code: ValidationErrorCode.MISSING_PRIMARY_KEY
+      });
+    }
+    for (const [fieldName, field] of Object.entries(table.fields)) {
+      if (RESERVED_FIELDS.includes(fieldName)) {
+        errors.push({
+          table: tableName,
+          field: fieldName,
+          message: `'${fieldName}' is a reserved field name`,
+          code: ValidationErrorCode.RESERVED_FIELD_NAME
+        });
+      }
+      const refTarget = getRefTarget(field);
+      if (refTarget) {
+        if (!tableNames.includes(refTarget)) {
+          errors.push({
+            table: tableName,
+            field: fieldName,
+            message: `Foreign key references non-existent table: ${refTarget}`,
+            code: ValidationErrorCode.INVALID_REFERENCE
+          });
+        }
+        if (refTarget === tableName && !field.nullable) {
+          errors.push({
+            table: tableName,
+            field: fieldName,
+            message: `Self-referencing foreign key must be nullable`,
+            code: ValidationErrorCode.SELF_REFERENCE_ON_REQUIRED
+          });
+        }
+      }
+      if (field.translatable && !["string", "text"].includes(field.type)) {
+        errors.push({
+          table: tableName,
+          field: fieldName,
+          message: `Only string/text fields can be translatable, got: ${field.type}`,
+          code: ValidationErrorCode.INVALID_TRANSLATABLE_TYPE
+        });
+      }
+    }
+  }
+  return errors;
+}
+function assertValidSchema(schema) {
+  const errors = validateSchema(schema);
+  if (errors.length > 0) {
+    const messages = errors.map((e) => e.field ? `[${e.table}.${e.field}] ${e.message}` : `[${e.table}] ${e.message}`);
+    throw new Error(`Schema validation failed:
+${messages.join(`
+`)}`);
+  }
+}
+function isValidSchema(schema) {
+  return validateSchema(schema).length === 0;
+}
+function validateTable(tableName, table, allTableNames) {
+  const errors = [];
+  const hasPrimaryKey = Object.values(table.fields).some((field) => field.primary);
+  if (!hasPrimaryKey) {
+    errors.push({
+      table: tableName,
+      message: "Table must have a primary key",
+      code: ValidationErrorCode.MISSING_PRIMARY_KEY
+    });
+  }
+  for (const [fieldName, field] of Object.entries(table.fields)) {
+    const refTarget = getRefTarget(field);
+    if (refTarget && !allTableNames.includes(refTarget)) {
+      errors.push({
+        table: tableName,
+        field: fieldName,
+        message: `Foreign key references non-existent table: ${refTarget}`,
+        code: ValidationErrorCode.INVALID_REFERENCE
+      });
+    }
+    if (field.translatable && !["string", "text"].includes(field.type)) {
+      errors.push({
+        table: tableName,
+        field: fieldName,
+        message: `Only string/text fields can be translatable`,
+        code: ValidationErrorCode.INVALID_TRANSLATABLE_TYPE
+      });
+    }
+  }
+  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")
+};
+
+// 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 = {
+    people: "person",
+    children: "child",
+    men: "man",
+    women: "woman",
+    teeth: "tooth",
+    feet: "foot",
+    mice: "mouse",
+    geese: "goose"
+  };
+  if (irregulars[word]) {
+    return irregulars[word];
+  }
+  if (word.endsWith("ies")) {
+    return word.slice(0, -3) + "y";
+  }
+  if (word.endsWith("ses") || word.endsWith("xes") || word.endsWith("zes") || word.endsWith("ches") || word.endsWith("shes")) {
+    return word.slice(0, -2);
+  }
+  if (word.endsWith("oes")) {
+    return word.slice(0, -2);
+  }
+  if (word.endsWith("s") && !word.endsWith("ss")) {
+    return word.slice(0, -1);
+  }
+  return word;
+}
+function toPascalCase(str) {
+  return str.split(/[_\-\s]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+}
+function toCamelCase(str) {
+  const pascal = toPascalCase(str);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function toSnakeCase(str) {
+  return str.replace(/([A-Z])/g, "_$1").replace(/[-\s]+/g, "_").toLowerCase().replace(/^_/, "");
+}
+function toInterfaceName(tableName) {
+  return toPascalCase(singularize(tableName));
+}
+function toDbInterfaceName(tableName) {
+  return "Db" + toInterfaceName(tableName);
+}
+function pluralize(word) {
+  const irregulars = {
+    person: "people",
+    child: "children",
+    man: "men",
+    woman: "women",
+    tooth: "teeth",
+    foot: "feet",
+    mouse: "mice",
+    goose: "geese"
+  };
+  if (irregulars[word]) {
+    return irregulars[word];
+  }
+  if (word.endsWith("y") && !/[aeiou]y$/.test(word)) {
+    return word.slice(0, -1) + "ies";
+  }
+  if (word.endsWith("s") || word.endsWith("x") || word.endsWith("z") || word.endsWith("ch") || word.endsWith("sh")) {
+    return word + "es";
+  }
+  if (word.endsWith("o") && /[^aeiou]o$/.test(word)) {
+    return word + "es";
+  }
+  return word + "s";
+}
+function toPascalCasePlural(tableName) {
+  return toPascalCase(tableName);
+}
+function toTranslationTableName(tableName) {
+  return `${tableName}_translations`;
+}
+function toTranslationFKName(tableName) {
+  return `${singularize(tableName)}_id`;
+}
+// src/utils/whereBuilder.ts
+var COMPARISON_OPERATORS = {
+  $eq: "=",
+  $ne: "!=",
+  $gt: ">",
+  $gte: ">=",
+  $lt: "<",
+  $lte: "<="
+};
+var LOGICAL_OPERATORS = new Set(["$and", "$or", "$nor"]);
+function processFieldOperators(field, operators) {
+  const parts = [];
+  const params = [];
+  for (const [op, value] of Object.entries(operators)) {
+    if (op in COMPARISON_OPERATORS) {
+      parts.push(`${field} ${COMPARISON_OPERATORS[op]} ?`);
+      params.push(value);
+    } else if (op === "$in" || op === "$nin") {
+      if (!Array.isArray(value)) {
+        throw new Error(`${op} operator requires an array value`);
+      }
+      if (value.length === 0) {
+        parts.push(op === "$in" ? "0 = 1" : "1 = 1");
+      } else {
+        const placeholders = value.map(() => "?").join(", ");
+        const keyword = op === "$in" ? "IN" : "NOT IN";
+        parts.push(`${field} ${keyword} (${placeholders})`);
+        params.push(...value);
+      }
+    } else if (op === "$like") {
+      parts.push(`${field} LIKE ?`);
+      params.push(value);
+    } else if (op === "$notLike") {
+      parts.push(`${field} NOT LIKE ?`);
+      params.push(value);
+    } else if (op === "$between") {
+      if (!Array.isArray(value) || value.length !== 2) {
+        throw new Error("$between operator requires an array of exactly 2 values");
+      }
+      parts.push(`${field} BETWEEN ? AND ?`);
+      params.push(value[0], value[1]);
+    } else if (op === "$isNull") {
+      parts.push(value ? `${field} IS NULL` : `${field} IS NOT NULL`);
+    } else if (op === "$not") {
+      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error("$not operator requires an object with operators");
+      }
+      const inner = processFieldOperators(field, value);
+      parts.push(`NOT (${inner.sql})`);
+      params.push(...inner.params);
+    } else {
+      throw new Error(`Unknown operator: ${op}`);
+    }
+  }
+  const sql = parts.length === 1 ? parts[0] : `(${parts.join(" AND ")})`;
+  return { sql, params };
+}
+function processFieldCondition(field, value) {
+  if (value === null) {
+    return { sql: `${field} IS NULL`, params: [] };
+  }
+  if (typeof value !== "object" || Array.isArray(value)) {
+    return { sql: `${field} = ?`, params: [value] };
+  }
+  return processFieldOperators(field, value);
+}
+function processCondition(where) {
+  const parts = [];
+  const params = [];
+  for (const [key, value] of Object.entries(where)) {
+    if (LOGICAL_OPERATORS.has(key)) {
+      if (!Array.isArray(value)) {
+        throw new Error(`${key} operator requires an array of conditions`);
+      }
+      const subResults = value.map((sub) => processCondition(sub));
+      const joiner = key === "$and" ? " AND " : " OR ";
+      const combined = subResults.map((r) => r.sql).join(joiner);
+      if (combined) {
+        const wrappedSql = key === "$nor" ? `NOT (${combined})` : `(${combined})`;
+        parts.push(wrappedSql);
+        subResults.forEach((r) => params.push(...r.params));
+      }
+    } else {
+      const result = processFieldCondition(key, value);
+      parts.push(result.sql);
+      params.push(...result.params);
+    }
+  }
+  return { sql: parts.join(" AND "), params };
+}
+function buildWhereClause(where) {
+  if (!where || Object.keys(where).length === 0) {
+    return { sql: "", params: [] };
+  }
+  return processCondition(where);
+}
+// src/utils/translationQuery.ts
+function buildAliasedWhereClause(where, alias) {
+  const result = buildWhereClause(where);
+  if (!alias || !result.sql) {
+    return result;
+  }
+  let sql = result.sql;
+  const fields = Object.keys(where).filter((k) => !k.startsWith("$"));
+  for (const field of fields) {
+    const regex = new RegExp(`\\b${field}\\b(?!\\.)`, "g");
+    sql = sql.replace(regex, `${alias}.${field}`);
+  }
+  return { sql, params: result.params };
+}
+function buildTranslationQuery(options) {
+  const {
+    table,
+    schema,
+    lang,
+    fallbackLang = schema.languages.default,
+    where,
+    orderBy,
+    limit,
+    offset
+  } = options;
+  const tableSchema = schema.tables[table];
+  if (!tableSchema) {
+    throw new Error(`Table not found in schema: ${table}`);
+  }
+  const translatableFields = getTranslatableFields(tableSchema);
+  if (translatableFields.length === 0) {
+    return buildSimpleQuery(table, { where, orderBy, limit, offset });
+  }
+  const transTable = toTranslationTableName(table);
+  const fkName = toTranslationFKName(table);
+  const mainAlias = "m";
+  const transAlias = "t";
+  const fallbackAlias = "fb";
+  const selectFields = [];
+  for (const [fieldName, field] of Object.entries(tableSchema.fields)) {
+    if (field.translatable) {
+      selectFields.push(`COALESCE(${transAlias}.${fieldName}, ${fallbackAlias}.${fieldName}) as ${fieldName}`);
+    } else {
+      selectFields.push(`${mainAlias}.${fieldName}`);
+    }
+  }
+  let sql = `SELECT ${selectFields.join(", ")}
+FROM ${table} ${mainAlias}
+LEFT JOIN ${transTable} ${transAlias}
+  ON ${mainAlias}.id = ${transAlias}.${fkName}
+  AND ${transAlias}.language_code = ?
+LEFT JOIN ${transTable} ${fallbackAlias}
+  ON ${mainAlias}.id = ${fallbackAlias}.${fkName}
+  AND ${fallbackAlias}.language_code = ?`;
+  const params = [lang, fallbackLang];
+  if (where && Object.keys(where).length > 0) {
+    const whereResult = buildAliasedWhereClause(where, mainAlias);
+    sql += `
+WHERE ${whereResult.sql}`;
+    params.push(...whereResult.params);
+  }
+  if (orderBy && orderBy.length > 0) {
+    const orderClauses = orderBy.map((o) => {
+      if (translatableFields.includes(o.field)) {
+        return `COALESCE(${transAlias}.${o.field}, ${fallbackAlias}.${o.field}) ${o.direction}`;
+      }
+      return `${mainAlias}.${o.field} ${o.direction}`;
+    });
+    sql += `
+ORDER BY ${orderClauses.join(", ")}`;
+  }
+  if (limit !== undefined) {
+    sql += `
+LIMIT ?`;
+    params.push(limit);
+  }
+  if (offset !== undefined) {
+    sql += `
+OFFSET ?`;
+    params.push(offset);
+  }
+  return { sql, params };
+}
+function buildTranslationQueryById(table, schema, id, lang, fallbackLang) {
+  return buildTranslationQuery({
+    table,
+    schema,
+    lang,
+    fallbackLang,
+    where: { id },
+    limit: 1
+  });
+}
+function buildSimpleQuery(table, options) {
+  let sql = `SELECT * FROM ${table}`;
+  const params = [];
+  if (options.where && Object.keys(options.where).length > 0) {
+    const whereResult = buildWhereClause(options.where);
+    sql += ` WHERE ${whereResult.sql}`;
+    params.push(...whereResult.params);
+  }
+  if (options.orderBy && options.orderBy.length > 0) {
+    const orderClauses = options.orderBy.map((o) => `${o.field} ${o.direction}`);
+    sql += ` ORDER BY ${orderClauses.join(", ")}`;
+  }
+  if (options.limit !== undefined) {
+    sql += ` LIMIT ?`;
+    params.push(options.limit);
+  }
+  if (options.offset !== undefined) {
+    sql += ` OFFSET ?`;
+    params.push(options.offset);
+  }
+  return { sql, params };
+}
+function buildTranslationInsert(table, schema, recordId, lang, data) {
+  const tableSchema = schema.tables[table];
+  if (!tableSchema) {
+    throw new Error(`Table not found in schema: ${table}`);
+  }
+  const translatableFields = getTranslatableFields(tableSchema);
+  const transTable = toTranslationTableName(table);
+  const fkName = toTranslationFKName(table);
+  const fields = [fkName, "language_code"];
+  const values = [recordId, lang];
+  for (const field of translatableFields) {
+    if (data[field] !== undefined) {
+      fields.push(field);
+      values.push(data[field]);
+    }
+  }
+  const placeholders = fields.map(() => "?").join(", ");
+  const sql = `INSERT INTO ${transTable} (${fields.join(", ")}) VALUES (${placeholders})`;
+  return { sql, params: values };
+}
+function buildTranslationUpsert(table, schema, recordId, lang, data) {
+  const tableSchema = schema.tables[table];
+  if (!tableSchema) {
+    throw new Error(`Table not found in schema: ${table}`);
+  }
+  const translatableFields = getTranslatableFields(tableSchema);
+  const transTable = toTranslationTableName(table);
+  const fkName = toTranslationFKName(table);
+  const fields = [fkName, "language_code"];
+  const values = [recordId, lang];
+  for (const field of translatableFields) {
+    if (data[field] !== undefined) {
+      fields.push(field);
+      values.push(data[field]);
+    }
+  }
+  const placeholders = fields.map(() => "?").join(", ");
+  const sql = `INSERT OR REPLACE INTO ${transTable} (${fields.join(", ")}) VALUES (${placeholders})`;
+  return { sql, params: values };
+}
+function extractTranslatableData(data, tableSchema) {
+  const translatableFields = getTranslatableFields(tableSchema);
+  const mainData = {};
+  const translatableData = {};
+  for (const [key, value] of Object.entries(data)) {
+    if (translatableFields.includes(key)) {
+      translatableData[key] = value;
+    } else if (key !== "translations") {
+      mainData[key] = value;
+    }
+  }
+  return { mainData, translatableData };
+}
+// src/utils/jsonConverter.ts
+function parseJSONSchema(json) {
+  const languages = {
+    default: json.defaultLanguage || json.languages[0] || "en",
+    supported: json.languages || ["en"]
+  };
+  const tables = {};
+  for (const [tableName, jsonTable] of Object.entries(json.tables)) {
+    const fields = {};
+    for (const [fieldName, jsonField] of Object.entries(jsonTable)) {
+      fields[fieldName] = convertJSONField(jsonField);
+    }
+    tables[tableName] = {
+      name: tableName,
+      fields
+    };
+  }
+  return {
+    name: json.name,
+    languages,
+    tables
+  };
+}
+function convertJSONField(jsonField) {
+  let ref;
+  if (jsonField.ref) {
+    if (typeof jsonField.ref === "string") {
+      ref = jsonField.ref;
+    } else {
+      ref = {
+        table: jsonField.ref.table,
+        field: jsonField.ref.field,
+        onDelete: jsonField.ref.onDelete,
+        onUpdate: jsonField.ref.onUpdate
+      };
+    }
+  }
+  return {
+    type: jsonField.type,
+    nullable: jsonField.nullable ?? !jsonField.required,
+    unique: jsonField.unique ?? false,
+    primary: jsonField.primary ?? false,
+    default: jsonField.default,
+    translatable: jsonField.translatable ?? false,
+    ref
+  };
+}
+export {
+  validateTable,
+  validateSchema,
+  validatePopulate,
+  toTranslationTableName,
+  toTranslationFKName,
+  toSnakeCase,
+  toPascalCasePlural,
+  toPascalCase,
+  toInterfaceName,
+  toDbInterfaceName,
+  toCamelCase,
+  singularize,
+  resolvePopulate,
+  pluralize,
+  parseJSONSchema,
+  mergeSchemas,
+  isValidSchema,
+  isRequiredField,
+  hasTranslatableFields,
+  getTranslationTableFields,
+  getTranslatableFields,
+  getRequiredFields,
+  getReferenceFields,
+  getRefTargetFull,
+  getRefTarget,
+  getPrimaryKeyField,
+  getPopulatableFields,
+  getNonTranslatableFields,
+  getMainTableFields,
+  getInsertableFields,
+  f,
+  extractTranslatableData,
+  defineSchema,
+  createSchemaUnsafe,
+  buildWhereClause,
+  buildTranslationUpsert,
+  buildTranslationQueryById,
+  buildTranslationQuery,
+  buildTranslationInsert,
+  assertValidSchema,
+  ValidationErrorCode,
+  ORM
+};