inibase 1.6.0 → 1.6.1

package/dist/index.d.ts

@@ -77,8 +77,9 @@ export default class Inibase {
     private uniqueMap;
     private schemaFileExtension;
     constructor(database: string, mainFolder?: string, language?: ErrorLang);
-    private static errorMessages;
     createError(name: ErrorCode, variable?: string | number | (string | number)[]): Error;
+    private validateName;
+    private validateSchema;
     private getFileExtension;
     private schemaToIdsPath;
     /**

package/dist/index.js

@@ -40,9 +40,9 @@ export default class Inibase {
     uniqueMap;
     schemaFileExtension = process.env.INIBASE_SCHEMA_EXTENSION ?? "json";
     constructor(database, mainFolder = ".", language = "en") {
-        Utils.validateName(database);
-        this.databasePath = join(mainFolder, database);
         this.language = language;
+        this.validateName(database);
+        this.databasePath = join(mainFolder, database);
         this.pageInfo = {};
         this.totalItems = new Map();
         this.uniqueMap = new Map();
@@ -58,87 +58,14 @@ export default class Inibase {
         else
             globalConfig.salt = Buffer.from(process.env.INIBASE_SECRET, "hex");
     }
-    static errorMessages = {
-        en: {
-            TABLE_EMPTY: "Table {variable} is empty",
-            TABLE_EXISTS: "Table {variable} already exists",
-            TABLE_NOT_EXISTS: "Table {variable} doesn't exist",
-            NO_SCHEMA: "Table {variable} does't have a schema",
-            GROUP_UNIQUE: "Group {variable} should be unique, got duplicated content in {variable}",
-            FIELD_UNIQUE: "Field {variable} should be unique, got {variable} instead",
-            FIELD_REQUIRED: "Field {variable} is required",
-            INVALID_ID: "The given ID(s) is/are not valid(s)",
-            INVALID_TYPE: "Expect {variable} to be {variable}, got {variable} instead",
-            INVALID_PARAMETERS: "The given parameters are not valid",
-            INVALID_REGEX_MATCH: "Field {variable} does not match the expected pattern",
-            INVALID_NAME: "Name {variable} is not valid",
-            NO_ENV: Number(process.versions.node.split(".").reduce((a, b) => a + b)) >= 26
-                ? "please run with '--env-file=.env'"
-                : "please use dotenv",
-        },
-        ar: {
-            TABLE_EMPTY: "الجدول {variable} فارغ",
-            TABLE_EXISTS: "الجدول {variable} موجود بالفعل",
-            TABLE_NOT_EXISTS: "الجدول {variable} غير موجود",
-            NO_SCHEMA: "الجدول {variable} ليس لديه مخطط",
-            GROUP_UNIQUE: "المجموعة {variable} يجب أن تكون فريدة، تم العثور على محتوى مكرر في {variable}",
-            FIELD_UNIQUE: "الحقل {variable} يجب أن يكون فريدًا، تم العثور على {variable} بدلاً من ذلك",
-            FIELD_REQUIRED: "الحقل {variable} مطلوب",
-            INVALID_ID: "المعرف أو المعرفات المقدمة غير صالحة",
-            INVALID_TYPE: "من المتوقع أن يكون {variable} من النوع {variable}، لكن تم العثور على {variable} بدلاً من ذلك",
-            INVALID_PARAMETERS: "المعلمات المقدمة غير صالحة",
-            INVALID_REGEX_MATCH: "الحقل {variable} لا يتطابق مع النمط المتوقع",
-            INVALID_NAME: "الاسم {variable} غير صالح",
-            NO_ENV: Number(process.versions.node.split(".").reduce((a, b) => a + b)) >= 26
-                ? "يرجى التشغيل باستخدام '--env-file=.env'"
-                : "يرجى استخدام dotenv",
-        },
-        fr: {
-            TABLE_EMPTY: "La table {variable} est vide",
-            TABLE_EXISTS: "La table {variable} existe déjà",
-            TABLE_NOT_EXISTS: "La table {variable} n'existe pas",
-            NO_SCHEMA: "La table {variable} n'a pas de schéma",
-            GROUP_UNIQUE: "Le groupe {variable} doit être unique, contenu dupliqué trouvé dans {variable}",
-            FIELD_UNIQUE: "Le champ {variable} doit être unique, trouvé {variable} à la place",
-            FIELD_REQUIRED: "Le champ {variable} est obligatoire",
-            INVALID_ID: "Le(s) ID donné(s) n'est/ne sont pas valide(s)",
-            INVALID_TYPE: "Attendu que {variable} soit de type {variable}, mais trouvé {variable} à la place",
-            INVALID_PARAMETERS: "Les paramètres donnés ne sont pas valides",
-            INVALID_REGEX_MATCH: "Le champ {variable} ne correspond pas au modèle attendu",
-            INVALID_NAME: "Le nom {variable} n'est pas valide",
-            NO_ENV: Number(process.versions.node.split(".").reduce((a, b) => a + b)) >= 26
-                ? "veuillez exécuter avec '--env-file=.env'"
-                : "veuillez utiliser dotenv",
-        },
-        es: {
-            TABLE_EMPTY: "La tabla {variable} está vacía",
-            TABLE_EXISTS: "La tabla {variable} ya existe",
-            TABLE_NOT_EXISTS: "La tabla {variable} no existe",
-            NO_SCHEMA: "La tabla {variable} no tiene un esquema",
-            GROUP_UNIQUE: "El grupo {variable} debe ser único, se encontró contenido duplicado en {variable}",
-            FIELD_UNIQUE: "El campo {variable} debe ser único, se encontró {variable} en su lugar",
-            FIELD_REQUIRED: "El campo {variable} es obligatorio",
-            INVALID_ID: "El/los ID proporcionado(s) no es/son válido(s)",
-            INVALID_TYPE: "Se espera que {variable} sea {variable}, pero se encontró {variable} en su lugar",
-            INVALID_PARAMETERS: "Los parámetros proporcionados no son válidos",
-            INVALID_REGEX_MATCH: "El campo {variable} no coincide con el patrón esperado",
-            INVALID_NAME: "El nombre {variable} no es válido",
-            NO_ENV: Number(process.versions.node.split(".").reduce((a, b) => a + b)) >= 26
-                ? "por favor ejecute con '--env-file=.env'"
-                : "por favor use dotenv",
-        },
-    };
     createError(name, variable) {
-        const errorMessage = Inibase.errorMessages[this.language]?.[name];
-        if (!errorMessage)
-            return new Error("ERR");
-        const error = new Error(variable
-            ? Array.isArray(variable)
-                ? errorMessage.replace(/\{variable\}/g, () => variable.shift()?.toString() ?? "")
-                : errorMessage.replaceAll("{variable}", `'${variable.toString()}'`)
-            : errorMessage.replaceAll("{variable}", ""));
-        error.name = name;
-        return error;
+        return Utils.createError(this.language, name, variable);
+    }
+    validateName(name) {
+        Utils.validateName(name, this.language);
+    }
+    validateSchema(schema) {
+        Utils.validateSchema(schema, this.language);
     }
     getFileExtension(tableName) {
         let mainExtension = this.fileExtension;
@@ -169,9 +96,9 @@ export default class Inibase {
      * @param {TableConfig} [config]
      */
     async createTable(tableName, schema, config) {
-        Utils.validateName(tableName);
+        this.validateName(tableName);
         if (schema)
-            Utils.validateSchema(schema);
+            this.validateSchema(schema);
         const tablePath = join(this.databasePath, tableName);
         if (await File.isExists(tablePath))
             throw this.createError("TABLE_EXISTS", tableName);
@@ -220,15 +147,15 @@ export default class Inibase {
      * @param {(TableConfig&{name?: string})} [config]
      */
     async updateTable(tableName, schema, config) {
-        Utils.validateName(tableName);
+        this.validateName(tableName);
         if (config?.name)
-            Utils.validateName(config.name);
+            this.validateName(config.name);
         const table = await this.getTable(tableName);
         if (!table)
             return;
         const tablePath = join(this.databasePath, tableName);
         if (schema) {
-            Utils.validateSchema(schema);
+            this.validateSchema(schema);
             // remove id from schema
             schema = schema.filter(({ key }) => !["id", "createdAt", "updatedAt"].includes(key));
             let schemaIdFilePath = "";
@@ -343,7 +270,7 @@ export default class Inibase {
      * @return {*}  {Promise<TableObject | undefined>}
      */
     async getTable(tableName) {
-        Utils.validateName(tableName);
+        this.validateName(tableName);
         const tablePath = join(this.databasePath, tableName);
         if (!(await File.isExists(tablePath)))
             throw this.createError("TABLE_NOT_EXISTS", tableName);
@@ -363,7 +290,7 @@ export default class Inibase {
         return globalConfig[this.databasePath].tables?.get(tableName);
     }
     async getTableSchema(tableName) {
-        Utils.validateName(tableName);
+        this.validateName(tableName);
         const tablePath = join(this.databasePath, tableName);
         let schemaFile;
         let schema;
@@ -1166,7 +1093,7 @@ export default class Inibase {
      * @param {string} tableName
      */
     async clearCache(tableName) {
-        Utils.validateName(tableName);
+        this.validateName(tableName);
         const cacheFolderPath = join(this.databasePath, tableName, ".cache");
         await rm(cacheFolderPath, { recursive: true, force: true });
         await mkdir(cacheFolderPath);
@@ -1175,7 +1102,7 @@ export default class Inibase {
         page: 1,
         perPage: 15,
     }, onlyOne, onlyLinesNumbers, _whereIsLinesNumbers) {
-        Utils.validateName(tableName);
+        this.validateName(tableName);
         const tablePath = join(this.databasePath, tableName);
         // Ensure options.columns is an array
         if (options.columns) {
@@ -1183,7 +1110,7 @@ export default class Inibase {
                 ? options.columns
                 : [options.columns];
             for (const column of options.columns)
-                Utils.validateName(column);
+                this.validateName(column);
             if (options.columns.length && !options.columns.includes("id"))
                 options.columns.push("id");
         }
@@ -1426,12 +1353,12 @@ export default class Inibase {
                 page: 1,
                 perPage: 15,
             };
-        Utils.validateName(tableName);
+        this.validateName(tableName);
         if (options.columns)
             for (const column of (Array.isArray(options.columns)
                 ? options.columns
                 : [options.columns]))
-                Utils.validateName(column);
+                this.validateName(column);
         const tablePath = join(this.databasePath, tableName);
         await this.getTable(tableName);
         if (!globalConfig[this.databasePath].tables?.get(tableName)?.schema)
@@ -1512,12 +1439,12 @@ export default class Inibase {
         perPage: 15,
     }, returnUpdatedData, _whereIsLinesNumbers) {
         const renameList = [];
-        Utils.validateName(tableName);
+        this.validateName(tableName);
         if (options.columns)
             for (const column of (Array.isArray(options.columns)
                 ? options.columns
                 : [options.columns]))
-                Utils.validateName(column);
+                this.validateName(column);
         const tablePath = join(this.databasePath, tableName);
         await this.throwErrorIfTableEmpty(tableName);
         let clonedData = structuredClone(data);
@@ -1632,7 +1559,7 @@ export default class Inibase {
      * @return {boolean | null}  {(Promise<boolean | null>)}
      */
     async delete(tableName, where, _whereIsLinesNumbers) {
-        Utils.validateName(tableName);
+        this.validateName(tableName);
         const tablePath = join(this.databasePath, tableName);
         await this.throwErrorIfTableEmpty(tableName);
         if (!where) {
@@ -1726,11 +1653,11 @@ export default class Inibase {
         return false;
     }
     async sum(tableName, columns, where) {
-        Utils.validateName(tableName);
+        this.validateName(tableName);
         if (!Array.isArray(columns))
             columns = [columns];
         for (const column of columns)
-            Utils.validateName(column);
+            this.validateName(column);
         await this.throwErrorIfTableEmpty(tableName);
         const RETURN = {};
         const tablePath = join(this.databasePath, tableName);
@@ -1750,11 +1677,11 @@ export default class Inibase {
         return columns.length > 1 ? RETURN : Object.values(RETURN)[0];
     }
     async max(tableName, columns, where) {
-        Utils.validateName(tableName);
+        this.validateName(tableName);
         if (!Array.isArray(columns))
             columns = [columns];
         for (const column of columns)
-            Utils.validateName(column);
+            this.validateName(column);
         const RETURN = {};
         const tablePath = join(this.databasePath, tableName);
         await this.throwErrorIfTableEmpty(tableName);
@@ -1774,11 +1701,11 @@ export default class Inibase {
         return RETURN;
     }
     async min(tableName, columns, where) {
-        Utils.validateName(tableName);
+        this.validateName(tableName);
         if (!Array.isArray(columns))
             columns = [columns];
         for (const column of columns)
-            Utils.validateName(column);
+            this.validateName(column);
         const RETURN = {};
         const tablePath = join(this.databasePath, tableName);
         await this.throwErrorIfTableEmpty(tableName);

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
-import type { ComparisonOperator, Field, FieldType, Schema } from "./index.js";
+import type { ComparisonOperator, ErrorCode, ErrorLang, Field, FieldType, Schema } from "./index.js";
 /**
  * Type guard function to check if the input is an array of objects.
  *
@@ -218,16 +218,31 @@ export declare const findLastIdNumber: (schema: Schema) => number;
 export declare function addIdToSchema(schema: Schema, startWithID: {
     value: number;
 }): Field[];
+/**
+ * Translated error messages for every supported language and error code.
+ * The `{variable}` placeholder is replaced with the relevant value by
+ * {@link createError}.
+ */
+export declare const ERROR_MESSAGES: Record<ErrorLang, Record<ErrorCode, string>>;
+/**
+ * Creates a translated error exactly like the ones thrown by Inibase methods.
+ *
+ * @param language - The language to render the error message in.
+ * @param name - The error code, also used as the error `name`.
+ * @param variable - Optional value(s) used to fill the `{variable}` placeholders.
+ * @returns An `Error` whose `name` is the error code and `message` is translated.
+ */
+export declare const createError: (language: ErrorLang, name: ErrorCode, variable?: string | number | (string | number)[]) => Error;
 /**
  * Validates that a string is a safe name for a table, database or column.
  *
- * Names must match `^[a-zA-Z0-9][a-zA-Z0-9_-]*$` (starts with an alphanumeric
- * character, followed by alphanumerics, underscores or hyphens) and be at most
- * 255 characters long.
+ * Names must start with an alphanumeric character (Latin or Arabic), followed
+ * by alphanumerics (Latin or Arabic), underscores, hyphens or spaces, and be
+ * at most 255 characters long. Leading or trailing spaces are not allowed.
  *
  * This prevents path traversal (`../`, `..\\`), null-byte injection (`\0`),
- * shell injection (`;`, `|`, backticks, `$()`, spaces, slashes) and other
- * reserved-name issues.
+ * shell injection (`;`, `|`, backticks, `$()`, tabs, newlines, slashes) and
+ * other reserved-name issues.
  *
  * @param input - The value to be checked.
  * @returns boolean - True if the name is safe to use, false otherwise.
@@ -235,16 +250,18 @@ export declare function addIdToSchema(schema: Schema, startWithID: {
 export declare const isValidName: (input: unknown) => input is string;
 /**
  * Validates that a string is a safe name for a table, database or column and
- * throws an error if it is not.
+ * throws a translated `INVALID_NAME` error if it is not.
  *
  * @param name - The name to validate.
+ * @param language - The language to render the error message in.
  * @throws {Error} If the name is not a safe name.
  */
-export declare const validateName: (name: string) => void;
+export declare const validateName: (name: string, language?: ErrorLang) => void;
 /**
  * Recursively validates every field key of a schema.
  *
  * @param schema - The schema to validate.
+ * @param language - The language to render the error message in.
  * @throws {Error} If any field key is not a safe name.
  */
-export declare const validateSchema: (schema: Schema) => void;
+export declare const validateSchema: (schema: Schema, language?: ErrorLang) => void;

package/dist/utils.js

@@ -628,16 +628,111 @@ export function addIdToSchema(schema, startWithID) {
     const addIdToSchemaHelper = (schema) => schema.map(addIdToField);
     return addIdToSchemaHelper(clonedSchema);
 }
+/**
+ * Translated error messages for every supported language and error code.
+ * The `{variable}` placeholder is replaced with the relevant value by
+ * {@link createError}.
+ */
+export const ERROR_MESSAGES = {
+    en: {
+        TABLE_EMPTY: "Table {variable} is empty",
+        TABLE_EXISTS: "Table {variable} already exists",
+        TABLE_NOT_EXISTS: "Table {variable} doesn't exist",
+        NO_SCHEMA: "Table {variable} does't have a schema",
+        GROUP_UNIQUE: "Group {variable} should be unique, got duplicated content in {variable}",
+        FIELD_UNIQUE: "Field {variable} should be unique, got {variable} instead",
+        FIELD_REQUIRED: "Field {variable} is required",
+        INVALID_ID: "The given ID(s) is/are not valid(s)",
+        INVALID_TYPE: "Expect {variable} to be {variable}, got {variable} instead",
+        INVALID_PARAMETERS: "The given parameters are not valid",
+        INVALID_REGEX_MATCH: "Field {variable} does not match the expected pattern",
+        INVALID_NAME: "Name {variable} is not valid",
+        NO_ENV: Number(process.versions.node.split(".").reduce((a, b) => a + b)) >= 26
+            ? "please run with '--env-file=.env'"
+            : "please use dotenv",
+    },
+    ar: {
+        TABLE_EMPTY: "الجدول {variable} فارغ",
+        TABLE_EXISTS: "الجدول {variable} موجود بالفعل",
+        TABLE_NOT_EXISTS: "الجدول {variable} غير موجود",
+        NO_SCHEMA: "الجدول {variable} ليس لديه مخطط",
+        GROUP_UNIQUE: "المجموعة {variable} يجب أن تكون فريدة، تم العثور على محتوى مكرر في {variable}",
+        FIELD_UNIQUE: "الحقل {variable} يجب أن يكون فريدًا، تم العثور على {variable} بدلاً من ذلك",
+        FIELD_REQUIRED: "الحقل {variable} مطلوب",
+        INVALID_ID: "المعرف أو المعرفات المقدمة غير صالحة",
+        INVALID_TYPE: "من المتوقع أن يكون {variable} من النوع {variable}، لكن تم العثور على {variable} بدلاً من ذلك",
+        INVALID_PARAMETERS: "المعلمات المقدمة غير صالحة",
+        INVALID_REGEX_MATCH: "الحقل {variable} لا يتطابق مع النمط المتوقع",
+        INVALID_NAME: "الاسم {variable} غير صالح",
+        NO_ENV: Number(process.versions.node.split(".").reduce((a, b) => a + b)) >= 26
+            ? "يرجى التشغيل باستخدام '--env-file=.env'"
+            : "يرجى استخدام dotenv",
+    },
+    fr: {
+        TABLE_EMPTY: "La table {variable} est vide",
+        TABLE_EXISTS: "La table {variable} existe déjà",
+        TABLE_NOT_EXISTS: "La table {variable} n'existe pas",
+        NO_SCHEMA: "La table {variable} n'a pas de schéma",
+        GROUP_UNIQUE: "Le groupe {variable} doit être unique, contenu dupliqué trouvé dans {variable}",
+        FIELD_UNIQUE: "Le champ {variable} doit être unique, trouvé {variable} à la place",
+        FIELD_REQUIRED: "Le champ {variable} est obligatoire",
+        INVALID_ID: "Le(s) ID donné(s) n'est/ne sont pas valide(s)",
+        INVALID_TYPE: "Attendu que {variable} soit de type {variable}, mais trouvé {variable} à la place",
+        INVALID_PARAMETERS: "Les paramètres donnés ne sont pas valides",
+        INVALID_REGEX_MATCH: "Le champ {variable} ne correspond pas au modèle attendu",
+        INVALID_NAME: "Le nom {variable} n'est pas valide",
+        NO_ENV: Number(process.versions.node.split(".").reduce((a, b) => a + b)) >= 26
+            ? "veuillez exécuter avec '--env-file=.env'"
+            : "veuillez utiliser dotenv",
+    },
+    es: {
+        TABLE_EMPTY: "La tabla {variable} está vacía",
+        TABLE_EXISTS: "La tabla {variable} ya existe",
+        TABLE_NOT_EXISTS: "La tabla {variable} no existe",
+        NO_SCHEMA: "La tabla {variable} no tiene un esquema",
+        GROUP_UNIQUE: "El grupo {variable} debe ser único, se encontró contenido duplicado en {variable}",
+        FIELD_UNIQUE: "El campo {variable} debe ser único, se encontró {variable} en su lugar",
+        FIELD_REQUIRED: "El campo {variable} es obligatorio",
+        INVALID_ID: "El/los ID proporcionado(s) no es/son válido(s)",
+        INVALID_TYPE: "Se espera que {variable} sea {variable}, pero se encontró {variable} en su lugar",
+        INVALID_PARAMETERS: "Los parámetros proporcionados no son válidos",
+        INVALID_REGEX_MATCH: "El campo {variable} no coincide con el patrón esperado",
+        INVALID_NAME: "El nombre {variable} no es válido",
+        NO_ENV: Number(process.versions.node.split(".").reduce((a, b) => a + b)) >= 26
+            ? "por favor ejecute con '--env-file=.env'"
+            : "por favor use dotenv",
+    },
+};
+/**
+ * Creates a translated error exactly like the ones thrown by Inibase methods.
+ *
+ * @param language - The language to render the error message in.
+ * @param name - The error code, also used as the error `name`.
+ * @param variable - Optional value(s) used to fill the `{variable}` placeholders.
+ * @returns An `Error` whose `name` is the error code and `message` is translated.
+ */
+export const createError = (language, name, variable) => {
+    const errorMessage = ERROR_MESSAGES[language]?.[name];
+    if (!errorMessage)
+        return new Error("ERR");
+    const error = new Error(variable
+        ? Array.isArray(variable)
+            ? errorMessage.replace(/\{variable\}/g, () => variable.shift()?.toString() ?? "")
+            : errorMessage.replaceAll("{variable}", `'${variable.toString()}'`)
+        : errorMessage.replaceAll("{variable}", ""));
+    error.name = name;
+    return error;
+};
 /**
  * Validates that a string is a safe name for a table, database or column.
  *
- * Names must match `^[a-zA-Z0-9][a-zA-Z0-9_-]*$` (starts with an alphanumeric
- * character, followed by alphanumerics, underscores or hyphens) and be at most
- * 255 characters long.
+ * Names must start with an alphanumeric character (Latin or Arabic), followed
+ * by alphanumerics (Latin or Arabic), underscores, hyphens or spaces, and be
+ * at most 255 characters long. Leading or trailing spaces are not allowed.
  *
  * This prevents path traversal (`../`, `..\\`), null-byte injection (`\0`),
- * shell injection (`;`, `|`, backticks, `$()`, spaces, slashes) and other
- * reserved-name issues.
+ * shell injection (`;`, `|`, backticks, `$()`, tabs, newlines, slashes) and
+ * other reserved-name issues.
  *
  * @param input - The value to be checked.
  * @returns boolean - True if the name is safe to use, false otherwise.
@@ -645,30 +740,38 @@ export function addIdToSchema(schema, startWithID) {
 export const isValidName = (input) => typeof input === "string" &&
     input.length > 0 &&
     input.length <= 255 &&
-    /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(input);
+    validNamePattern.test(input);
+// Word characters: Latin alphanumerics, underscores, hyphens and Arabic blocks.
+const nameWordCharClass = "a-zA-Z0-9_\\u0600-\\u06FF\\u0750-\\u077F\\u08A0-\\u08FF-";
+// Leading characters: same as word chars minus underscore and hyphen.
+const nameFirstCharClass = "a-zA-Z0-9\\u0600-\\u06FF\\u0750-\\u077F\\u08A0-\\u08FF";
+// eslint-disable-next-line no-misleading-character-class
+const validNamePattern = new RegExp(`^[${nameFirstCharClass}](?:[${nameWordCharClass} ]*[${nameWordCharClass}])?$`);
 /**
  * Validates that a string is a safe name for a table, database or column and
- * throws an error if it is not.
+ * throws a translated `INVALID_NAME` error if it is not.
  *
  * @param name - The name to validate.
+ * @param language - The language to render the error message in.
  * @throws {Error} If the name is not a safe name.
  */
-export const validateName = (name) => {
+export const validateName = (name, language = "en") => {
     if (!isValidName(name))
-        throw new Error(`Invalid name: '${name}'. Names must contain only alphanumeric characters, underscores or hyphens, must start with an alphanumeric character and must be at most 255 characters long.`);
+        throw createError(language, "INVALID_NAME", name);
 };
 /**
  * Recursively validates every field key of a schema.
  *
  * @param schema - The schema to validate.
+ * @param language - The language to render the error message in.
  * @throws {Error} If any field key is not a safe name.
  */
-export const validateSchema = (schema) => {
+export const validateSchema = (schema, language = "en") => {
     for (const field of schema) {
-        validateName(field.key);
+        validateName(field.key, language);
         if (field.table)
-            validateName(field.table);
+            validateName(field.table, language);
         if (field.children && isArrayOfObjects(field.children))
-            validateSchema(field.children);
+            validateSchema(field.children, language);
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "inibase",
-  "version": "1.6.0",
+  "version": "1.6.1",
   "type": "module",
   "author": {
     "name": "Karim Amahtil",