adminizer 4.0.0-commit.f9bffe6 → 4.1.0-build.0

package/lib/v4/model/adapter/sequelize.js

@@ -0,0 +1,280 @@
+import { DataTypes, Op } from "sequelize";
+import { AbstractAdapter, AbstractModel } from "../AbstractModel";
+import path from "path";
+import fs from "fs";
+import { pathToFileURL } from "url";
+function mapSequelizeAttributesToAbstract(attrs) {
+    const result = {};
+    for (const key in attrs) {
+        const attr = attrs[key];
+        const resolvedType = resolveType(attr.type);
+        result[key] = {
+            type: resolvedType,
+            required: !attr.allowNull,
+            primaryKey: !!attr.primaryKey,
+            unique: !!attr.unique,
+        };
+    }
+    return result;
+}
+function resolveType(type) {
+    try {
+        const sqlType = typeof type.toString === "function"
+            ? type.toString().toLowerCase()
+            : "";
+        if (sqlType.includes("string"))
+            return "string";
+        if (sqlType.includes("uuid"))
+            return "string";
+        if (sqlType.includes("int") || sqlType.includes("float") || sqlType.includes("decimal"))
+            return "number";
+        if (sqlType.includes("bool"))
+            return "boolean";
+        if (sqlType.includes("json"))
+            return "json";
+        if (sqlType.includes("date"))
+            return "string"; // 👈 фикс: дата как строка
+        return "ref";
+    }
+    catch {
+        return "ref";
+    }
+}
+/** SequelizeModel — реализация модели, совместимая с AbstractModel */
+function convertCriteriaToSequelize(criteria) {
+    console.log("waterline criteria", criteria);
+    const result = {};
+    for (const key in criteria) {
+        const value = criteria[key];
+        if (value === undefined ||
+            value === null ||
+            (typeof value === "object" && Object.keys(value).length === 0)) {
+            continue; // ⛔ пропускаем пустые условия
+        }
+        if (typeof value === "object" && !Array.isArray(value)) {
+            const operatorEntries = Object.entries(value)
+                .filter(([_, v]) => v !== undefined && v !== null)
+                .map(([op, val]) => {
+                switch (op) {
+                    case "contains": return [Op.like, `%${val}%`];
+                    case "startsWith": return [Op.startsWith, val];
+                    case "endsWith": return [Op.endsWith, val];
+                    case ">": return [Op.gt, val];
+                    case ">=": return [Op.gte, val];
+                    case "<": return [Op.lt, val];
+                    case "<=": return [Op.lte, val];
+                    case "!=": return [Op.ne, val];
+                    case "in": return [Op.in, val];
+                    case "nin": return [Op.notIn, val];
+                    default: return [Op.eq, val];
+                }
+            });
+            if (operatorEntries.length > 0) {
+                result[key] = Object.fromEntries(operatorEntries);
+            }
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function convertWaterlineCriteriaToSequelizeOptions(criteria) {
+    console.log("WATERLINE CRITERIA", criteria);
+    const { where = {}, skip, limit, sort } = criteria;
+    const result = {
+        where: convertCriteriaToSequelize(where),
+    };
+    if (typeof skip === "number") {
+        result.offset = skip;
+    }
+    if (typeof limit === "number") {
+        result.limit = limit;
+    }
+    if (typeof sort === "string") {
+        const [field, direction] = sort.trim().split(/\s+/);
+        result.order = [[field, direction?.toUpperCase() === "DESC" ? "DESC" : "ASC"]];
+    }
+    return result;
+}
+export class SequelizeModel extends AbstractModel {
+    model;
+    constructor(modelName, model) {
+        super(modelName, mapSequelizeAttributesToAbstract(model.getAttributes()), model.primaryKeyAttribute, model.name);
+        this.model = model;
+    }
+    // --- CREATE ---
+    async _create(data) {
+        const created = await this.model.create(data);
+        const result = await this.model.findByPk(created.get(this.primaryKey), { raw: true });
+        return result;
+    }
+    // --- FIND ONE ---
+    async _findOne(criteria) {
+        const { where } = convertWaterlineCriteriaToSequelizeOptions(criteria);
+        const result = await this.model.findOne({
+            where,
+            include: this._buildIncludes(),
+            raw: true,
+        });
+        return result;
+    }
+    // --- FIND MANY ---
+    async _find(criteria = {}, options = {}) {
+        const { where, limit, offset, order } = convertWaterlineCriteriaToSequelizeOptions(criteria);
+        const include = options.populate
+            ? options.populate.map(([field, opts]) => ({ association: field, ...opts }))
+            : this._buildIncludes();
+        const result = await this.model.findAll({
+            where,
+            limit,
+            offset,
+            order,
+            include,
+            raw: true,
+        });
+        return result;
+    }
+    // --- UPDATE ONE ---
+    async _updateOne(criteria, data) {
+        const { where } = convertWaterlineCriteriaToSequelizeOptions(criteria);
+        const record = await this.model.findOne({ where });
+        if (!record) {
+            return null;
+        }
+        await record.update(data);
+        const result = await this.model.findByPk(record.get(this.primaryKey), { raw: true });
+        return result;
+    }
+    // --- UPDATE MANY ---
+    async _update(criteria, data) {
+        const { where } = convertWaterlineCriteriaToSequelizeOptions(criteria);
+        await this.model.update(data, { where });
+        const result = await this.model.findAll({ where, raw: true });
+        return result;
+    }
+    // --- DESTROY ONE ---
+    async _destroyOne(criteria) {
+        const { where } = convertWaterlineCriteriaToSequelizeOptions(criteria);
+        const record = await this.model.findOne({ where });
+        if (!record) {
+            return null;
+        }
+        const raw = record.get({ plain: true });
+        await record.destroy();
+        return raw;
+    }
+    // --- DESTROY MANY ---
+    async _destroy(criteria) {
+        const { where } = convertWaterlineCriteriaToSequelizeOptions(criteria);
+        const records = await this.model.findAll({ where });
+        const raw = records.map(r => r.get({ plain: true }));
+        await this.model.destroy({ where });
+        return raw;
+    }
+    // --- COUNT ---
+    async _count(criteria = {}) {
+        const { where } = convertWaterlineCriteriaToSequelizeOptions(criteria);
+        const result = await this.model.count({ where });
+        return result;
+    }
+    // --- HELPER ---
+    _buildIncludes() {
+        return Object.keys(this.model.associations).map(key => ({ association: key }));
+    }
+}
+/** SequelizeAdapter — адаптер, заменяющий WaterlineAdapter */
+export class SequelizeAdapter extends AbstractAdapter {
+    sequelize;
+    Model = SequelizeModel;
+    constructor(sequelize) {
+        super("sequelize", sequelize);
+        this.sequelize = sequelize;
+    }
+    get models() {
+        return this.sequelize.models;
+    }
+    getModel(modelName) {
+        const matchedKey = Object.keys(this.sequelize.models).find(key => key.toLowerCase() === modelName.toLowerCase());
+        if (!matchedKey) {
+            return undefined;
+        }
+        return this.sequelize.models[matchedKey];
+    }
+    getAttributes(modelName) {
+        const model = this.getModel(modelName);
+        return model?.getAttributes();
+    }
+    /** Регистрация системных моделей */
+    static async registerSystemModels(sequelize) {
+        const modelsDir = path.resolve(import.meta.dirname, "../../../../models");
+        const files = fs.readdirSync(modelsDir).filter(f => f.endsWith(".js"));
+        for (const file of files) {
+            const modelName = path.basename(file, path.extname(file));
+            const filePath = path.resolve(modelsDir, file);
+            const definition = (await import(pathToFileURL(filePath).href)).default;
+            generateSequelizeModel(sequelize, modelName, definition);
+        }
+        await sequelize.sync();
+    }
+}
+/** Генерация модели Sequelize из определения, аналог WaterlineCollection.extend */
+function generateSequelizeModel(sequelize, modelName, rawAttributes) {
+    const attributes = {};
+    let primaryKey = null;
+    for (const field in rawAttributes) {
+        const attr = { ...rawAttributes[field] };
+        // 💥 Skip associations (handled separately)
+        if (attr.model || attr.collection) {
+            continue;
+        }
+        if (attr.primaryKey) {
+            primaryKey = field;
+            attr.primaryKey = true;
+        }
+        if (attr.uuid && attr.type === "string") {
+            attr.type = DataTypes.UUID;
+            attr.defaultValue = DataTypes.UUIDV4;
+            delete attr.uuid;
+        }
+        if (attr.autoIncrement) {
+            attr.autoIncrement = true;
+        }
+        if (attr.unique) {
+            attr.unique = true;
+        }
+        if (typeof attr.type === "string") {
+            switch (attr.type) {
+                case "string":
+                    attr.type = DataTypes.STRING;
+                    break;
+                case "number":
+                    attr.type = DataTypes.INTEGER;
+                    break;
+                case "boolean":
+                    attr.type = DataTypes.BOOLEAN;
+                    break;
+                case "json":
+                    attr.type = DataTypes.JSON;
+                    break;
+                case "ref":
+                    attr.type = DataTypes.JSON;
+                    break;
+                case "datetime":
+                case "date":
+                    attr.type = DataTypes.DATE;
+                    break;
+                default:
+                    throw new Error(`Unrecognized datatype "${attr.type}" for field "${field}" in model "${modelName}"`);
+            }
+        }
+        attributes[field] = attr;
+    }
+    if (!primaryKey) {
+        throw new Error(`Model "${modelName}" must have a primary key`);
+    }
+    return sequelize.define(modelName, attributes, {
+        tableName: modelName.toLowerCase(),
+        timestamps: true,
+    });
+}

package/lib/v4/model/adapter/waterline.js

@@ -47,7 +47,9 @@ export class WaterlineModel extends AbstractModel {
         if (options.limit && typeof options.limit === "number") {
             query = query.limit(options.limit);
         }
-        return await query;
+        let result = await query;
+        console.log(result, "result");
+        return result;
     }
     async _updateOne(criteria, data) {
         return await this.model.updateOne(criteria).set(data);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "adminizer",
   "type": "module",
-  "version": "4.0.0-commit.f9bffe6",
+  "version": "4.1.0-build.0",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
@@ -19,7 +19,7 @@
     "build:assets:modules": "npm run build:assets && npm run copy:modules",
     "start:seed": "cross-env SEED_DATA=true tsx --tsconfig ./waterlineFixture/tsconfig.json ./waterlineFixture/index.ts",
     "demo:build": "npm run copy:backend && npm run compile:backend && npm run build:assets && npm run copy:modules",
-    "demo": "npm run start:seed"
+    "demo": "cross-env DEMO=true npm run start:seed"
   },
   "keywords": [],
   "author": "",
@@ -117,6 +117,9 @@
     "vite": "^6.1.0",
     "vite-plugin-externals": "^0.6.2",
     "vite-plugin-full-reload": "^1.2.0",
-    "waterline": "^0.15.2"
+    "waterline": "^0.15.2",
+    "sqlite3": "^5.1.7",
+    "sequelize": "^6.37.5",
+    "sequelize-typescript": "^2.1.6"
   }
 }

package/policies/checkAuth.js

@@ -3,7 +3,7 @@ export default async function checkAuth(req, res, proceed) {
     if (typeof req.adminizer.config.translation !== 'boolean') {
         locale = req.adminizer.config.translation.defaultLocale;
     }
-    if (!req.adminizer.config.auth) {
+    if (!req.adminizer.config.auth.enable) {
         if (req.session.UserAP) {
             req.session.UserAP.isAdministrator = true;
         }

package/system/bindAuthorization.js

@@ -60,15 +60,30 @@ export default async function bindAuthorization(adminizer) {
         console.table(adminsCredentials);
         console.groupEnd();
     }
+    else if (process.env.ADMINPANEL_DEMO_ADMIN_ENABLE !== undefined) {
+        try {
+            let passwordHashed = generate("demodemo");
+            let password = 'masked';
+            // TODO refactor CRUD functions for DataAccessor usage
+            await adminizer.modelHandler.model.get("UserAP")?.["_create"]({
+                login: 'demo', password: 'demo', passwordHashed: passwordHashed, fullName: "Administrator",
+                isActive: true, isAdministrator: true
+            });
+        }
+        catch (e) {
+            Adminizer.log.error("Could not create demo administrator profile", e);
+            return;
+        }
+    }
     else { // try to create one if we don't
-        if (adminizer.config.auth) {
+        if (adminizer.config.auth.enable) {
             Adminizer.log.debug(`Adminpanel does not have an administrator`);
             adminizer.config.policies.push(initUserPolicy);
             //@ts-ignore
             adminizer.app.use(`${adminizer.config.routePrefix}/init_user`, _initUser);
         }
     }
-    if (adminizer.config.auth) {
+    if (adminizer.config.auth.enable) {
         adminizer.app.use(baseRoute + '/login', adminizer.policyManager.bindPolicies(policies, _login));
         adminizer.app.use(baseRoute + '/logout', adminizer.policyManager.bindPolicies(policies, _login));
         adminizer.app.use(baseRoute + '/register', adminizer.policyManager.bindPolicies(policies, _register));

package/system/bindInertia.js

@@ -132,7 +132,7 @@ function checkAuth(req, adminizer) {
     if (typeof adminizer.config.translation !== 'boolean') {
         locale = adminizer.config.translation.defaultLocale;
     }
-    if (!adminizer.config.auth) {
+    if (!adminizer.config.auth.enable) {
         if (req.session.UserAP) {
             req.session.UserAP.isAdministrator = true;
         }

package/system/defaults.js

@@ -107,6 +107,9 @@ var adminpanelConfig = {
         enable: false,
         defaultUserGroup: "guest",
         confirmationRequired: true
+    },
+    auth: {
+        enable: false
     }
 };
 export function setDefaultConfig(config) {