adminizer 4.6.0 → 4.7.0-build.221

package/lib/model/adapter/waterline.js

@@ -1,180 +0,0 @@
-import { AbstractAdapter, AbstractModel } from "../AbstractModel.js";
-import { v4 as uuid } from "uuid";
-import Waterline from "waterline";
-import path from "node:path";
-import fs from "fs";
-import { pathToFileURL } from "url";
-export class WaterlineModel extends AbstractModel {
-    model;
-    constructor(modelName, model) {
-        super(modelName, model.attributes, model.primaryKey, model.identity);
-        if (!model) {
-            throw new Error('Model instance must be provided.');
-        }
-        this.model = model;
-    }
-    async _create(data) {
-        return await this.model.create(data).fetch();
-    }
-    /** Custom populate all function */
-    async populateAll(query, model) {
-        // Get 'model' and 'collection' fields
-        const associations = Object.keys(model.attributes)
-            .filter(attr => model.attributes[attr].model || model.attributes[attr].collection);
-        // Dynamically populate all associations
-        associations.forEach(attr => {
-            query = query.populate(attr);
-        });
-        return query;
-    }
-    async _findOne(criteria) {
-        let query = this.model.findOne(criteria);
-        query = await this.populateAll(query, this.model);
-        return await query;
-    }
-    async _find(criteria = {}, options = {}) {
-        // Hack
-        const attributes = this.model.attributes;
-        const associations = Object.keys(attributes).filter(attr => attributes[attr].model || attributes[attr].collection);
-        if (JSON.stringify(criteria.where) === '{}') {
-            let sortField;
-            if (criteria?.sort) {
-                if (typeof criteria.sort === 'string') {
-                    sortField = criteria.sort.split(' ')[0];
-                }
-                else if (Array.isArray(criteria.sort)) {
-                    sortField = criteria.sort[0];
-                }
-            }
-            if (sortField && associations.includes(sortField)) {
-                criteria.sort = undefined;
-            }
-        }
-        let query = this.model.find(criteria);
-        if (options.populate && Array.isArray(options.populate) && options.populate.length > 0) {
-            options.populate.forEach(([field, populateCriteria]) => {
-                if (typeof field === "string") {
-                    query = query.populate(field, populateCriteria || {});
-                }
-            });
-        }
-        else {
-            query = await this.populateAll(query, this.model);
-        }
-        if (options.limit && typeof options.limit === "number") {
-            query = query.limit(options.limit);
-        }
-        let result = await query;
-        return result;
-    }
-    async _updateOne(criteria, data) {
-        return await this.model.updateOne(criteria).set(data);
-    }
-    async _update(criteria, data) {
-        return await this.model.update(criteria).set(data).fetch();
-    }
-    async _destroyOne(criteria) {
-        return await this.model.destroyOne(criteria);
-    }
-    async _destroy(criteria) {
-        return await this.model.destroy(criteria).fetch();
-    }
-    async _count(criteria = {}) {
-        return await this.model.count(criteria);
-    }
-}
-export class WaterlineAdapter extends AbstractAdapter {
-    Model = WaterlineModel;
-    /** In case of waterline, we are storing complex object in "orm" field of our AbstractAdapter.
-     * It contains waterline orm and waterline ontology. One for storing methods like registerModel and initialize,
-     * the other for storing collections with methods find, create etc. Also, we need waterlineConfig */
-    constructor(orm) {
-        super("waterline", orm);
-    }
-    get models() {
-        return this.orm.ontology.collections;
-    }
-    getModel(modelName) {
-        const matchedKey = Object.keys(this.orm.ontology.collections).find(key => key.toLowerCase() === modelName.toLowerCase());
-        if (!matchedKey) {
-            return undefined;
-        }
-        return this.orm.ontology.collections[matchedKey];
-    }
-    getAttributes(modelName) {
-        const model = this.getModel(modelName);
-        if (!model) {
-            throw new Error(`Model "${modelName}" was not found`);
-        }
-        return model.attributes;
-    }
-    /** Method that processes custom waterline model creation. Is used for system models. Replaces beforeCreate method in waterline */
-    static async registerSystemModels(waterlineORM) {
-        let systemModelsDir = path.resolve(import.meta.dirname, "../../../../models");
-        if (!fs.existsSync(systemModelsDir)) {
-            systemModelsDir = path.resolve(import.meta.dirname, "../../../../src/models");
-        }
-        let systemModelsFiles = fs.readdirSync(systemModelsDir).filter(file => file.endsWith(".js"));
-        if (!systemModelsFiles.length) {
-            systemModelsFiles = fs.readdirSync(systemModelsDir).filter(file => file.endsWith(".ts") && !file.endsWith(".d.ts"));
-        }
-        // Register adminizer system models
-        await Promise.all(systemModelsFiles.map(async (file) => {
-            const modelName = path.basename(file).replace(/\.(ts|js)$/, "");
-            const systemModelPath = path.resolve(systemModelsDir, file);
-            const adminizerModel = (await import(pathToFileURL(systemModelPath).href)).default;
-            const waterlineLikeModel = generateWaterlineModel(modelName, structuredClone(adminizerModel));
-            // Register model in Waterline ORM
-            waterlineORM.registerModel(waterlineLikeModel);
-        }));
-        function generateWaterlineModel(modelName, attributes) {
-            attributes = JSON.parse(JSON.stringify(attributes));
-            const primaryKey = Object.keys(attributes).find(fieldName => attributes[fieldName]?.primaryKey === true);
-            if (!primaryKey) {
-                throw new Error(`Model "${modelName}" must have a primary key.`);
-            }
-            // Bind beforeCreate hook for creating UUID
-            let beforeCreate = (record, cb) => cb();
-            if (attributes[primaryKey]?.uuid === true && attributes[primaryKey]?.type === "string") {
-                beforeCreate = (record, cb) => {
-                    if (!record.id) {
-                        record.id = uuid();
-                    }
-                    cb();
-                };
-                // Delete uuid field after processing
-                delete attributes[primaryKey].uuid;
-            }
-            // Moving autoincrement and unique fields into autoMigrations
-            Object.keys(attributes).forEach((key) => {
-                if (!attributes[key].autoMigrations) {
-                    attributes[key].autoMigrations = {};
-                }
-                if (attributes[key].autoIncrement) {
-                    attributes[key].autoMigrations.autoIncrement = true;
-                    delete attributes[key].autoIncrement;
-                }
-                if (attributes[key].unique) {
-                    attributes[key].autoMigrations.unique = true;
-                    delete attributes[key].unique;
-                }
-            });
-            // Convert date and datetime fields to ref
-            Object.keys(attributes).forEach((key) => {
-                const attr = attributes[key];
-                if (attr.type === 'datetime' || attr.type === 'date') {
-                    attr.type = 'ref';
-                }
-            });
-            // Delete primaryKey key, waterline does not want it (wants only in upper level)
-            delete attributes[primaryKey].primaryKey;
-            return Waterline.Collection.extend({
-                identity: modelName.toLowerCase(),
-                datastore: 'default',
-                primaryKey: primaryKey,
-                attributes: attributes,
-                beforeCreate: beforeCreate
-            });
-        }
-    }
-}

package/migrations/index.d.ts

@@ -1,3 +0,0 @@
-export declare const migrations: {
-    umzug: import("..").Migration[];
-};

package/migrations/index.js

@@ -1,4 +0,0 @@
-import { umzugExports } from "./umzugExports.js";
-export const migrations = {
-    umzug: umzugExports
-};

package/migrations/knex/20250106000001_adminizer_init.d.ts

@@ -1,8 +0,0 @@
-import { Knex } from "knex";
-/**
- * Creates all system model tables for Adminizer
- * Tables: userap, groupap, mediamanagerap, mediamanagermetaap, mediamanagerassociationsap,
- *         notificationap, usernotificationap, navigationap, groupapuserap
- */
-export declare function up(knex: Knex): Promise<void>;
-export declare function down(knex: Knex): Promise<void>;

package/migrations/knex/20250106000001_adminizer_init.js

@@ -1,164 +0,0 @@
-/**
- * Creates all system model tables for Adminizer
- * Tables: userap, groupap, mediamanagerap, mediamanagermetaap, mediamanagerassociationsap,
- *         notificationap, usernotificationap, navigationap, groupapuserap
- */
-export async function up(knex) {
-    // Helper to get the correct default timestamp based on database client
-    const getDefaultTimestamp = () => {
-        const client = knex.client.config.client;
-        if (client === 'pg' || client === 'postgresql') {
-            return knex.raw('CURRENT_TIMESTAMP');
-        }
-        else if (client === 'sqlite3') {
-            return knex.raw("(datetime('now'))");
-        }
-        else if (client === 'mysql' || client === 'mysql2') {
-            return knex.raw('CURRENT_TIMESTAMP');
-        }
-        return knex.fn.now();
-    };
-    // Helper to get UUID default based on database client
-    const getUuidDefault = () => {
-        const client = knex.client.config.client;
-        if (client === 'pg' || client === 'postgresql') {
-            return knex.raw('gen_random_uuid()');
-        }
-        else if (client === 'sqlite3') {
-            // SQLite doesn't have native UUID, will need to handle in application
-            return undefined;
-        }
-        return knex.raw('UUID()');
-    };
-    const defaultTimestamp = getDefaultTimestamp();
-    const uuidDefault = getUuidDefault();
-    // userap
-    await knex.schema.createTable("userap", (table) => {
-        table.increments("id").primary().notNullable();
-        table.string("login").unique();
-        table.string("fullName");
-        table.string("email");
-        table.string("avatar");
-        table.string("passwordHashed");
-        table.string("timezone");
-        table.string("expires");
-        table.string("locale");
-        table.boolean("isDeleted");
-        table.boolean("isActive");
-        table.boolean("isAdministrator");
-        table.json("widgets");
-        table.boolean("isConfirmed");
-        table.timestamp("createdAt", { useTz: false }).notNullable().defaultTo(defaultTimestamp);
-        table.timestamp("updatedAt", { useTz: false }).notNullable().defaultTo(defaultTimestamp);
-    });
-    // groupap
-    await knex.schema.createTable("groupap", (table) => {
-        table.increments("id").primary().notNullable();
-        table.string("name").unique();
-        table.string("description");
-        table.json("tokens");
-        table.timestamp("createdAt", { useTz: false }).notNullable().defaultTo(defaultTimestamp);
-        table.timestamp("updatedAt", { useTz: false }).notNullable().defaultTo(defaultTimestamp);
-    });
-    // mediamanagerap (self-ref via parent)
-    await knex.schema.createTable("mediamanagerap", (table) => {
-        if (uuidDefault) {
-            table.uuid("id").primary().notNullable().defaultTo(uuidDefault);
-        }
-        else {
-            table.uuid("id").primary().notNullable();
-        }
-        table.uuid("parent").nullable().references("id").inTable("mediamanagerap");
-        table.string("mimeType");
-        table.string("path");
-        table.integer("size");
-        table.string("group");
-        table.string("tag");
-        table.string("url");
-        table.string("filename");
-        table.timestamp("createdAt", { useTz: false }).notNullable().defaultTo(defaultTimestamp);
-        table.timestamp("updatedAt", { useTz: false }).notNullable().defaultTo(defaultTimestamp);
-    });
-    // mediamanagermetaap (belongsTo mediamanagerap via parent)
-    await knex.schema.createTable("mediamanagermetaap", (table) => {
-        if (uuidDefault) {
-            table.uuid("id").primary().notNullable().defaultTo(uuidDefault);
-        }
-        else {
-            table.uuid("id").primary().notNullable();
-        }
-        table.string("key");
-        table.json("value");
-        table.boolean("isPublic");
-        table.uuid("parent").nullable().references("id").inTable("mediamanagerap");
-        table.timestamp("createdAt", { useTz: false }).notNullable().defaultTo(defaultTimestamp);
-        table.timestamp("updatedAt", { useTz: false }).notNullable().defaultTo(defaultTimestamp);
-    });
-    // mediamanagerassociationsap (belongsTo mediamanagerap via file)
-    await knex.schema.createTable("mediamanagerassociationsap", (table) => {
-        if (uuidDefault) {
-            table.uuid("id").primary().notNullable().defaultTo(uuidDefault);
-        }
-        else {
-            table.uuid("id").primary().notNullable();
-        }
-        table.string("mediaManagerId");
-        table.string("model");
-        table.integer("modelId");
-        table.string("widgetName");
-        table.integer("sortOrder");
-        table.uuid("file").nullable().references("id").inTable("mediamanagerap");
-        table.timestamp("createdAt", { useTz: false }).notNullable().defaultTo(defaultTimestamp);
-        table.timestamp("updatedAt", { useTz: false }).notNullable().defaultTo(defaultTimestamp);
-    });
-    // notificationap
-    await knex.schema.createTable("notificationap", (table) => {
-        table.increments("id").primary().notNullable();
-        table.string("title");
-        table.string("message");
-        table.string("notificationClass");
-        table.string("channel");
-        table.json("metadata");
-        table.timestamp("createdAt", { useTz: false }).notNullable().defaultTo(defaultTimestamp);
-        table.timestamp("updatedAt", { useTz: false }).notNullable().defaultTo(defaultTimestamp);
-    });
-    // usernotificationap (FK to notificationap via column notificationIdId)
-    await knex.schema.createTable("usernotificationap", (table) => {
-        table.increments("id").primary().notNullable();
-        table.integer("userId");
-        table.integer("notificationIdId").nullable().references("id").inTable("notificationap");
-        table.boolean("read");
-        table.timestamp("createdAt", { useTz: false }).notNullable().defaultTo(defaultTimestamp);
-        table.timestamp("updatedAt", { useTz: false }).notNullable().defaultTo(defaultTimestamp);
-    });
-    // navigationap
-    await knex.schema.createTable("navigationap", (table) => {
-        table.increments("id").primary().notNullable();
-        table.string("label").unique();
-        table.json("tree");
-        table.timestamp("createdAt", { useTz: false }).notNullable().defaultTo(defaultTimestamp);
-        table.timestamp("updatedAt", { useTz: false }).notNullable().defaultTo(defaultTimestamp);
-    });
-    // M:N join: GroupAP <-> UserAP via "groupap_users__userap_groups"
-    // Waterline naming convention: {model1}_{collection1}__{model2}_{collection2}
-    // GroupAP.users -> UserAP.groups => groupap_users__userap_groups
-    // Column naming: {model}_{collection} references the TARGET model
-    await knex.schema.createTable("groupap_users__userap_groups", (table) => {
-        table.increments("id").primary().notNullable();
-        table.integer("groupap_users").notNullable().references("id").inTable("groupap");
-        table.integer("userap_groups").notNullable().references("id").inTable("userap");
-        table.timestamp("createdAt", { useTz: false }).notNullable().defaultTo(defaultTimestamp);
-        table.timestamp("updatedAt", { useTz: false }).notNullable().defaultTo(defaultTimestamp);
-    });
-}
-export async function down(knex) {
-    await knex.schema.dropTableIfExists("groupap_users__userap_groups");
-    await knex.schema.dropTableIfExists("usernotificationap");
-    await knex.schema.dropTableIfExists("mediamanagermetaap");
-    await knex.schema.dropTableIfExists("mediamanagerassociationsap");
-    await knex.schema.dropTableIfExists("mediamanagerap");
-    await knex.schema.dropTableIfExists("navigationap");
-    await knex.schema.dropTableIfExists("notificationap");
-    await knex.schema.dropTableIfExists("groupap");
-    await knex.schema.dropTableIfExists("userap");
-}

package/migrations/umzug/0001.d.ts

@@ -1,7 +0,0 @@
-import { QueryInterface } from "sequelize";
-type Ctx = {
-    context: QueryInterface;
-};
-export declare function up({ context }: Ctx): Promise<void>;
-export declare function down({ context }: Ctx): Promise<void>;
-export {};

package/migrations/umzug/0001.js

@@ -1,121 +0,0 @@
-import { DataTypes } from "sequelize";
-// Creates all system model tables according to src/models/* and
-// SequelizeAdapter.generateSequelizeModel naming: tableName = modelName.toLowerCase()
-// Associations:
-// - UserAP <-> GroupAP: M:N via through table "groupapuserap" (UserAPId, GroupAPId)
-// - MediaManagerAP.parent -> MediaManagerAP (parentId)
-// - MediaManagerAP hasMany MediaManagerMetaAP via parent (MediaManagerMetaAP.parentId)
-// - MediaManagerAP hasMany MediaManagerAssociationsAP via file (MediaManagerAssociationsAP.fileId)
-// - UserNotificationAP belongsTo NotificationAP via alias "notificationId" -> FK column "notificationIdId"
-export async function up({ context }) {
-    // userap
-    await context.createTable("userap", {
-        id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true, allowNull: false },
-        login: { type: DataTypes.STRING, unique: true },
-        fullName: { type: DataTypes.STRING },
-        email: { type: DataTypes.STRING },
-        avatar: { type: DataTypes.STRING },
-        passwordHashed: { type: DataTypes.STRING },
-        timezone: { type: DataTypes.STRING },
-        expires: { type: DataTypes.STRING },
-        locale: { type: DataTypes.STRING },
-        isDeleted: { type: DataTypes.BOOLEAN },
-        isActive: { type: DataTypes.BOOLEAN },
-        isAdministrator: { type: DataTypes.BOOLEAN },
-        widgets: { type: DataTypes.JSON },
-        isConfirmed: { type: DataTypes.BOOLEAN },
-        createdAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
-        updatedAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
-    });
-    // groupap
-    await context.createTable("groupap", {
-        id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true, allowNull: false },
-        name: { type: DataTypes.STRING, unique: true },
-        description: { type: DataTypes.STRING },
-        tokens: { type: DataTypes.JSON },
-        createdAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
-        updatedAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
-    });
-    // mediamanagerap (self-ref via parentId)
-    await context.createTable("mediamanagerap", {
-        id: { type: DataTypes.UUID, defaultValue: DataTypes.UUIDV4, primaryKey: true, allowNull: false },
-        parentId: { type: DataTypes.UUID, allowNull: true, references: { model: "mediamanagerap", key: "id" } },
-        mimeType: { type: DataTypes.STRING },
-        path: { type: DataTypes.STRING },
-        size: { type: DataTypes.INTEGER },
-        group: { type: DataTypes.STRING },
-        tag: { type: DataTypes.STRING },
-        url: { type: DataTypes.STRING },
-        filename: { type: DataTypes.STRING },
-        createdAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
-        updatedAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
-    });
-    // mediamanagermetaap (belongsTo mediamanagerap via parentId)
-    await context.createTable("mediamanagermetaap", {
-        id: { type: DataTypes.UUID, defaultValue: DataTypes.UUIDV4, primaryKey: true, allowNull: false },
-        key: { type: DataTypes.STRING },
-        value: { type: DataTypes.JSON },
-        isPublic: { type: DataTypes.BOOLEAN },
-        parentId: { type: DataTypes.UUID, allowNull: true, references: { model: "mediamanagerap", key: "id" } },
-        createdAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
-        updatedAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
-    });
-    // mediamanagerassociationsap (belongsTo mediamanagerap via fileId)
-    await context.createTable("mediamanagerassociationsap", {
-        id: { type: DataTypes.UUID, defaultValue: DataTypes.UUIDV4, primaryKey: true, allowNull: false },
-        mediaManagerId: { type: DataTypes.STRING },
-        model: { type: DataTypes.STRING },
-        modelId: { type: DataTypes.INTEGER },
-        widgetName: { type: DataTypes.STRING },
-        sortOrder: { type: DataTypes.INTEGER },
-        fileId: { type: DataTypes.UUID, allowNull: true, references: { model: "mediamanagerap", key: "id" } },
-        createdAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
-        updatedAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
-    });
-    // notificationap
-    await context.createTable("notificationap", {
-        id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true, allowNull: false },
-        title: { type: DataTypes.STRING },
-        message: { type: DataTypes.STRING },
-        notificationClass: { type: DataTypes.STRING },
-        channel: { type: DataTypes.STRING },
-        metadata: { type: DataTypes.JSON },
-        createdAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
-        updatedAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
-    });
-    // usernotificationap (FK to notificationap via column notificationIdId)
-    await context.createTable("usernotificationap", {
-        id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true, allowNull: false },
-        userId: { type: DataTypes.INTEGER },
-        notificationIdId: { type: DataTypes.INTEGER, allowNull: true, references: { model: "notificationap", key: "id" } },
-        read: { type: DataTypes.BOOLEAN },
-        createdAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
-        updatedAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
-    });
-    // navigationap
-    await context.createTable("navigationap", {
-        id: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true, allowNull: false },
-        label: { type: DataTypes.STRING, unique: true },
-        tree: { type: DataTypes.JSON },
-        createdAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
-        updatedAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
-    });
-    // M:N join: GroupAP <-> UserAP via "groupapuserap"
-    await context.createTable("groupapuserap", {
-        UserAPId: { type: DataTypes.INTEGER, allowNull: false, references: { model: "userap", key: "id" } },
-        GroupAPId: { type: DataTypes.INTEGER, allowNull: false, references: { model: "groupap", key: "id" } },
-        createdAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
-        updatedAt: { type: DataTypes.DATE, allowNull: false, defaultValue: DataTypes.NOW },
-    });
-}
-export async function down({ context }) {
-    await context.dropTable("groupapuserap");
-    await context.dropTable("usernotificationap");
-    await context.dropTable("mediamanagermetaap");
-    await context.dropTable("mediamanagerassociationsap");
-    await context.dropTable("mediamanagerap");
-    await context.dropTable("navigationap");
-    await context.dropTable("notificationap");
-    await context.dropTable("groupap");
-    await context.dropTable("userap");
-}

package/migrations/umzugExports.d.ts

@@ -1,2 +0,0 @@
-import { Migration } from "../interfaces/types";
-export declare const umzugExports: Migration[];

package/migrations/umzugExports.js

@@ -1,9 +0,0 @@
-import { up as up0001, down as down0001 } from "./umzug/0001.js";
-export const umzugExports = [
-    {
-        name: "0001",
-        timestamp: 1757930548596,
-        up: up0001,
-        down: down0001
-    }
-];

package/system/bindForms.d.ts

@@ -1,2 +0,0 @@
-import { Adminizer } from "../lib/Adminizer";
-export default function bindForms(adminizer: Adminizer): Promise<void>;

package/system/bindForms.js

@@ -1,20 +0,0 @@
-import * as fs from "fs";
-import { FormHelper } from "../helpers/formHelper.js";
-export default async function bindForms(adminizer) {
-    if (fs.existsSync(adminizer.config.forms.path)) {
-        let formsDir = fs.readdirSync(adminizer.config.forms.path);
-        if (formsDir.length) {
-            FormHelper.loadForms(adminizer, `${process.cwd()}/${adminizer.config.forms.path}`);
-        }
-    }
-    adminizer.emitter.on("adminizer:loaded", async () => {
-        // Seeding forms data
-        for (let form in adminizer.config.forms.data) {
-            for (let key in adminizer.config.forms.data[form]) {
-                if (await adminizer.config.forms.get(form, key) === undefined) {
-                    await adminizer.config.forms.set(form, key, adminizer.config.forms.data[form][key].value);
-                }
-            }
-        }
-    });
-}