inibase 1.5.11 → 1.6.1

package/dist/cli.js

@@ -7,7 +7,8 @@ import { parseArgs } from "node:util";
 import Inison from "inison";
 import { isExists } from "./file.js";
 import Inibase, {} from "./index.js";
-import { isNumber, isStringified, setField, unsetField } from "./utils.js";
+import { isNumber, isStringified, isValidName, setField, unsetField, } from "./utils.js";
+const isSafeName = (input) => isValidName(input);
 const textGreen = (input) => `\u001b[1;32m${input}\u001b[0m`;
 const textRed = (input) => `\u001b[1;31m${input}\u001b[0m`;
 const textBlue = (input) => `\u001b[1;34m${input}\u001b[0m`;
@@ -178,7 +179,9 @@ rl.on("line", async (input) => {
                 console.log(`${textRed("  Err:")} Please specify table name`);
                 break;
             }
-            if (!(await isExists(join(path, splitedInput[1]))))
+            if (!isSafeName(splitedInput[1]))
+                console.log(`${textRed("  Err:")} Invalid table name, only alphanumeric characters, underscores and hyphens are allowed`);
+            else if (!(await isExists(join(path, splitedInput[1]))))
                 console.log(`${textRed("  Err:")} Table doesn't exist`);
             else {
                 table = splitedInput[1];

package/dist/index.d.ts

@@ -51,7 +51,7 @@ declare global {
         entries<T extends object>(o: T): Entries<T>;
     }
 }
-export declare const ERROR_CODES: readonly ["GROUP_UNIQUE", "FIELD_UNIQUE", "FIELD_REQUIRED", "NO_SCHEMA", "TABLE_EMPTY", "INVALID_ID", "INVALID_TYPE", "INVALID_PARAMETERS", "NO_ENV", "TABLE_EXISTS", "TABLE_NOT_EXISTS", "INVALID_REGEX_MATCH"];
+export declare const ERROR_CODES: readonly ["GROUP_UNIQUE", "FIELD_UNIQUE", "FIELD_REQUIRED", "NO_SCHEMA", "TABLE_EMPTY", "INVALID_ID", "INVALID_TYPE", "INVALID_PARAMETERS", "NO_ENV", "TABLE_EXISTS", "TABLE_NOT_EXISTS", "INVALID_REGEX_MATCH", "INVALID_NAME"];
 export type ErrorCode = (typeof ERROR_CODES)[number];
 export type ErrorLang = "en" | "ar" | "fr" | "es";
 export declare const globalConfig: {
@@ -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

@@ -21,6 +21,7 @@ export const ERROR_CODES = [
     "TABLE_EXISTS",
     "TABLE_NOT_EXISTS",
     "INVALID_REGEX_MATCH",
+    "INVALID_NAME",
 ];
 // hide ExperimentalWarning glob()
 process.removeAllListeners("warning");
@@ -39,8 +40,9 @@ export default class Inibase {
     uniqueMap;
     schemaFileExtension = process.env.INIBASE_SCHEMA_EXTENSION ?? "json";
     constructor(database, mainFolder = ".", language = "en") {
-        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();
@@ -56,83 +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",
-            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} لا يتطابق مع النمط المتوقع",
-            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",
-            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",
-            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;
@@ -163,6 +96,9 @@ export default class Inibase {
      * @param {TableConfig} [config]
      */
     async createTable(tableName, schema, config) {
+        this.validateName(tableName);
+        if (schema)
+            this.validateSchema(schema);
         const tablePath = join(this.databasePath, tableName);
         if (await File.isExists(tablePath))
             throw this.createError("TABLE_EXISTS", tableName);
@@ -211,11 +147,15 @@ export default class Inibase {
      * @param {(TableConfig&{name?: string})} [config]
      */
     async updateTable(tableName, schema, config) {
+        this.validateName(tableName);
+        if (config?.name)
+            this.validateName(config.name);
         const table = await this.getTable(tableName);
         if (!table)
             return;
         const tablePath = join(this.databasePath, tableName);
         if (schema) {
+            this.validateSchema(schema);
             // remove id from schema
             schema = schema.filter(({ key }) => !["id", "createdAt", "updatedAt"].includes(key));
             let schemaIdFilePath = "";
@@ -330,6 +270,7 @@ export default class Inibase {
      * @return {*}  {Promise<TableObject | undefined>}
      */
     async getTable(tableName) {
+        this.validateName(tableName);
         const tablePath = join(this.databasePath, tableName);
         if (!(await File.isExists(tablePath)))
             throw this.createError("TABLE_NOT_EXISTS", tableName);
@@ -349,6 +290,7 @@ export default class Inibase {
         return globalConfig[this.databasePath].tables?.get(tableName);
     }
     async getTableSchema(tableName) {
+        this.validateName(tableName);
         const tablePath = join(this.databasePath, tableName);
         let schemaFile;
         let schema;
@@ -1151,6 +1093,7 @@ export default class Inibase {
      * @param {string} tableName
      */
     async clearCache(tableName) {
+        this.validateName(tableName);
         const cacheFolderPath = join(this.databasePath, tableName, ".cache");
         await rm(cacheFolderPath, { recursive: true, force: true });
         await mkdir(cacheFolderPath);
@@ -1159,12 +1102,15 @@ export default class Inibase {
         page: 1,
         perPage: 15,
     }, onlyOne, onlyLinesNumbers, _whereIsLinesNumbers) {
+        this.validateName(tableName);
         const tablePath = join(this.databasePath, tableName);
         // Ensure options.columns is an array
         if (options.columns) {
             options.columns = Array.isArray(options.columns)
                 ? options.columns
                 : [options.columns];
+            for (const column of options.columns)
+                this.validateName(column);
             if (options.columns.length && !options.columns.includes("id"))
                 options.columns.push("id");
         }
@@ -1407,6 +1353,12 @@ export default class Inibase {
                 page: 1,
                 perPage: 15,
             };
+        this.validateName(tableName);
+        if (options.columns)
+            for (const column of (Array.isArray(options.columns)
+                ? options.columns
+                : [options.columns]))
+                this.validateName(column);
         const tablePath = join(this.databasePath, tableName);
         await this.getTable(tableName);
         if (!globalConfig[this.databasePath].tables?.get(tableName)?.schema)
@@ -1487,6 +1439,12 @@ export default class Inibase {
         perPage: 15,
     }, returnUpdatedData, _whereIsLinesNumbers) {
         const renameList = [];
+        this.validateName(tableName);
+        if (options.columns)
+            for (const column of (Array.isArray(options.columns)
+                ? options.columns
+                : [options.columns]))
+                this.validateName(column);
         const tablePath = join(this.databasePath, tableName);
         await this.throwErrorIfTableEmpty(tableName);
         let clonedData = structuredClone(data);
@@ -1601,6 +1559,7 @@ export default class Inibase {
      * @return {boolean | null}  {(Promise<boolean | null>)}
      */
     async delete(tableName, where, _whereIsLinesNumbers) {
+        this.validateName(tableName);
         const tablePath = join(this.databasePath, tableName);
         await this.throwErrorIfTableEmpty(tableName);
         if (!where) {
@@ -1694,11 +1653,14 @@ export default class Inibase {
         return false;
     }
     async sum(tableName, columns, where) {
-        const RETURN = {};
-        const tablePath = join(this.databasePath, tableName);
-        await this.throwErrorIfTableEmpty(tableName);
+        this.validateName(tableName);
         if (!Array.isArray(columns))
             columns = [columns];
+        for (const column of columns)
+            this.validateName(column);
+        await this.throwErrorIfTableEmpty(tableName);
+        const RETURN = {};
+        const tablePath = join(this.databasePath, tableName);
         for await (const column of columns) {
             const columnPath = join(tablePath, `${column}${this.getFileExtension(tableName)}`);
             if (await File.isExists(columnPath)) {
@@ -1715,11 +1677,14 @@ export default class Inibase {
         return columns.length > 1 ? RETURN : Object.values(RETURN)[0];
     }
     async max(tableName, columns, where) {
+        this.validateName(tableName);
+        if (!Array.isArray(columns))
+            columns = [columns];
+        for (const column of columns)
+            this.validateName(column);
         const RETURN = {};
         const tablePath = join(this.databasePath, tableName);
         await this.throwErrorIfTableEmpty(tableName);
-        if (!Array.isArray(columns))
-            columns = [columns];
         for await (const column of columns) {
             const columnPath = join(tablePath, `${column}${this.getFileExtension(tableName)}`);
             if (await File.isExists(columnPath)) {
@@ -1736,11 +1701,14 @@ export default class Inibase {
         return RETURN;
     }
     async min(tableName, columns, where) {
+        this.validateName(tableName);
+        if (!Array.isArray(columns))
+            columns = [columns];
+        for (const column of columns)
+            this.validateName(column);
         const RETURN = {};
         const tablePath = join(this.databasePath, tableName);
         await this.throwErrorIfTableEmpty(tableName);
-        if (!Array.isArray(columns))
-            columns = [columns];
         for await (const column of columns) {
             const columnPath = join(tablePath, `${column}${this.getFileExtension(tableName)}`);
             if (await File.isExists(columnPath)) {

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,3 +218,50 @@ 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 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, `$()`, 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.
+ */
+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 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, 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, language?: ErrorLang) => void;

package/dist/utils.js

@@ -628,3 +628,150 @@ 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 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, `$()`, 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.
+ */
+export const isValidName = (input) => typeof input === "string" &&
+    input.length > 0 &&
+    input.length <= 255 &&
+    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 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, language = "en") => {
+    if (!isValidName(name))
+        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, language = "en") => {
+    for (const field of schema) {
+        validateName(field.key, language);
+        if (field.table)
+            validateName(field.table, language);
+        if (field.children && isArrayOfObjects(field.children))
+            validateSchema(field.children, language);
+    }
+};

package/package.json

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