@medyll/idae-machine 0.87.0

package/dist/db/dbFields.js

@@ -0,0 +1,606 @@
+/*
+    path: D:\boulot\python\wollama\src\lib\db\dbFields.ts
+ */
+import { schemeModel } from './dbSchema';
+export var enumPrimitive;
+(function (enumPrimitive) {
+    enumPrimitive["id"] = "id";
+    enumPrimitive["any"] = "any";
+    enumPrimitive["date"] = "date";
+    enumPrimitive["datetime"] = "datetime";
+    enumPrimitive["time"] = "time";
+    enumPrimitive["text"] = "text";
+    enumPrimitive["number"] = "number";
+    enumPrimitive["boolean"] = "boolean";
+    enumPrimitive["url"] = "url";
+    enumPrimitive["email"] = "email";
+    enumPrimitive["phone"] = "phone";
+    enumPrimitive["password"] = "password";
+})(enumPrimitive || (enumPrimitive = {}));
+export var TplProperties;
+(function (TplProperties) {
+    TplProperties["private"] = "private";
+    TplProperties["readonly"] = "readonly";
+    TplProperties["required"] = "required";
+})(TplProperties || (TplProperties = {}));
+const a = 'any(private required readonly)';
+/*
+    renamed from DbCollectionError to IDbErrors
+ */
+class IDbError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'DbCollectionError';
+    }
+    static throwError(message, code) {
+        throw new IDbError(message, code);
+    }
+    static handleError(error) {
+        if (error instanceof IDbError) {
+            console.error(`${error.name}: ${error.message} (Code: ${error.code})`);
+        }
+        else {
+            console.error('Unexpected error:', error);
+        }
+    }
+}
+// renammed from IDbFields to IDbCollections
+export class IDbCollections {
+    model = schemeModel;
+    constructor(model) {
+        this.model = schemeModel; //model ?? this.model;
+    }
+    parseAllCollections() {
+        let out = {};
+        Object.keys(this.model).forEach((collection) => {
+            out[collection] = this.parseRawCollection(collection);
+        });
+        return out;
+    }
+    parseRawCollection(collection) {
+        const fields = this.getCollectionTemplateFields(collection);
+        if (!fields)
+            return;
+        let out = {};
+        Object.keys(fields).forEach((fieldName) => {
+            const fieldType = fields[fieldName];
+            if (fieldType) {
+                out[fieldName] = this.parseCollectionFieldName(collection, fieldName);
+            }
+        });
+        return out;
+    }
+    parseCollectionFieldName(collection, fieldName) {
+        const field = this.#getTemplateFieldRule(collection, fieldName);
+        if (!field) {
+            IDbError.throwError(`Field ${fieldName} not found in collection ${collection}`, 'FIELD_NOT_FOUND');
+            return undefined;
+        }
+        const fieldType = this.testIs('primitive', field) ??
+            this.testIs('array', field) ??
+            this.testIs('object', field) ??
+            this.testIs('fk', field);
+        return this.forge({ collection, fieldName, ...fieldType });
+    }
+    parsFieldRule(fieldRule) {
+        if (!fieldRule)
+            return;
+        const fieldType = this.testIs('primitive', fieldRule) ??
+            this.testIs('array', fieldRule) ??
+            this.testIs('object', fieldRule) ??
+            this.testIs('fk', fieldRule);
+        return fieldType;
+    }
+    forge({ collection, fieldName, fieldType, fieldRule, fieldArgs, is }) {
+        return {
+            collection,
+            fieldName,
+            fieldType,
+            fieldRule,
+            fieldArgs,
+            is
+        };
+    }
+    #getModel() {
+        return this.model;
+    }
+    getCollection(collection) {
+        return this.#getModel()[String(collection)];
+    }
+    getCollectionTemplate(collection) {
+        return this.getCollection(collection)['template'];
+    }
+    getCollectionTemplateFks(collection) {
+        return this.getCollection(collection)['template']?.fks;
+    }
+    getIndexName(collection) {
+        return this.getCollection(collection)?.template?.index;
+    }
+    getCollectionTemplateFields(collection) {
+        return this.getCollectionTemplate(collection)?.fields;
+    }
+    getTemplatePresentation(collection) {
+        return this.getCollectionTemplate(collection)?.presentation;
+    }
+    #getTemplateFieldRule(collection, fieldName) {
+        return this.getCollectionTemplateFields(collection)?.[String(fieldName)];
+    }
+    getFkFieldType(string) {
+        const [collection, field] = string.split('.');
+        let template = this.#getTemplateFieldRule(collection, field);
+        return template;
+    }
+    getFkTemplateFields(string) {
+        const [collection, field] = string.split('.');
+        return this.getCollection(collection).template?.fields;
+    }
+    testIs(what, fieldRule) {
+        const typeMappings = {
+            fk: 'fk-',
+            array: 'array-of-',
+            object: 'object-',
+            primitive: ''
+        };
+        const prefix = typeMappings[what];
+        if (fieldRule.startsWith(prefix)) {
+            return this.is(what, fieldRule);
+        }
+        return undefined;
+    }
+    is(what, fieldRule) {
+        return this.extract(what, fieldRule);
+    }
+    indexValue(collection, data) {
+        let presentation = this.getIndexName(collection);
+        return data[presentation];
+    }
+    extract(type, fieldRule) {
+        // fieldType
+        function extractAfter(pattern, source) {
+            // remove all between () on source
+            const reg = source?.split('(')?.[0];
+            return reg.split(pattern)[1];
+        }
+        function extractArgs(source) {
+            const [piece, remaining] = source.split('(');
+            if (!remaining)
+                return { piece: piece.trim(), args: undefined };
+            const [central] = remaining?.split(')');
+            const args = central?.split(' ');
+            // console.log({ piece, args });
+            return { piece: piece.trim(), args };
+        }
+        let extractedArgs = extractArgs(fieldRule);
+        let fieldType;
+        let is = extractedArgs?.piece;
+        let fieldArgs = extractedArgs?.args;
+        switch (type) {
+            case 'array':
+                fieldType = extractAfter('array-of-', fieldRule);
+                is = is ?? fieldType;
+                break;
+            case 'object':
+                fieldType = extractAfter('object-', fieldRule);
+                is = is ?? fieldType;
+                break;
+            case 'fk':
+                fieldType = this.getFkFieldType(extractAfter('fk-', fieldRule));
+                is = extractedArgs?.piece;
+                break;
+            case 'primitive':
+                fieldType = extractedArgs?.piece;
+                is = is ?? fieldType;
+                break;
+        }
+        return { fieldType, fieldRule, fieldArgs, is: type };
+    }
+    fks(collection) {
+        let fks = this.getCollectionTemplateFks(collection);
+        let out = {};
+        // loop over fks
+        if (fks) {
+            Object.keys(fks).forEach((collection) => {
+                out[collection] = this.parseRawCollection(collection);
+            });
+        }
+        return out;
+    }
+    reverseFks(targetCollection) {
+        const result = {};
+        Object.entries(this.#getModel()).forEach(([collectionName, collectionModel]) => {
+            const template = collectionModel.template;
+            if (template && template.fks) {
+                Object.entries(template.fks).forEach(([fkName, fkConfig]) => {
+                    if (fkConfig?.code === targetCollection) {
+                        if (!result[collectionName]) {
+                            result[collectionName] = {};
+                        }
+                        result[collectionName][fkName] = fkConfig;
+                    }
+                });
+            }
+        });
+        return result;
+    }
+    // iterate base
+    iterateArrayField(collection, fieldName, data) {
+        const fieldInfo = this.parseCollectionFieldName(collection, fieldName);
+        if (fieldInfo?.is !== 'array' || !Array.isArray(data)) {
+            return [];
+        }
+        return data.map(() => this.parseCollectionFieldName(collection, fieldName));
+    }
+    iterateObjectField(collection, fieldName, data) {
+        const fieldInfo = this.parseCollectionFieldName(collection, fieldName);
+        if (fieldInfo?.is !== 'object' || typeof data !== 'object') {
+            return [];
+        }
+        return Object.keys(data).map((key) => this.parseCollectionFieldName(collection, key));
+    }
+}
+// display field values, based on schema and provided data
+// renamed from iDBFieldValues to iDbCollectionValues
+// path D:\boulot\python\wollama\src\lib\db\dbFields.ts
+export class IDbCollectionValues {
+    dbCollections;
+    collection;
+    constructor(collection) {
+        this.collection = collection;
+        this.dbCollections = new IDbCollections();
+    }
+    presentation(data) {
+        try {
+            this.#checkError(!this.#checkAccess(), 'Access denied', 'ACCESS_DENIED');
+            const presentation = this.dbCollections.getTemplatePresentation(this.collection);
+            this.#checkError(!presentation, 'Presentation template not found', 'TEMPLATE_NOT_FOUND');
+            const fields = presentation.split(' ');
+            return fields
+                .map((field) => {
+                const value = data[field];
+                return value !== null && value !== undefined ? String(value) : '';
+            })
+                .join(' ');
+        }
+        catch (error) {
+            IDbError.handleError(error);
+            return '';
+        }
+    }
+    indexValue(data) {
+        try {
+            this.#checkError(!this.#checkAccess(), 'Access denied', 'ACCESS_DENIED');
+            const indexName = this.dbCollections.getIndexName(this.collection);
+            this.#checkError(!indexName, 'Index not found for collection', 'INDEX_NOT_FOUND');
+            this.#checkError(!(indexName in data), `Index field ${indexName} not found in data`, 'FIELD_NOT_FOUND');
+            return data[indexName];
+        }
+        catch (error) {
+            IDbError.handleError(error);
+            return null;
+        }
+    }
+    format(fieldName, data) {
+        try {
+            this.#checkError(!this.#checkAccess(), 'Access denied', 'ACCESS_DENIED');
+            this.#checkError(!(fieldName in data), `Field ${String(fieldName)} not found in data`, 'FIELD_NOT_FOUND');
+            const fieldInfo = this.dbCollections.parseCollectionFieldName(this.collection, fieldName);
+            this.#checkError(!fieldInfo, `Field ${String(fieldName)} not found in collection`, 'FIELD_NOT_FOUND');
+            switch (fieldInfo?.fieldType) {
+                case 'number':
+                    return this.#formatNumberField(data[fieldName]);
+                case 'text':
+                case 'text-tiny':
+                case 'text-short':
+                case 'text-medium':
+                case 'text-long':
+                case 'text-giant':
+                    return this.#formatTextField(data[fieldName], fieldInfo.fieldType);
+                default:
+                    return String(data[fieldName]);
+            }
+        }
+        catch (error) {
+            IDbError.handleError(error);
+            return '';
+        }
+    }
+    getInputDataSet(fieldName, data) {
+        const fieldInfo = this.dbCollections.parseCollectionFieldName(this.collection, fieldName);
+        const fieldType = fieldInfo?.fieldType ?? '';
+        const fieldArgs = fieldInfo?.fieldArgs?.join(' ') ?? '';
+        const indexName = this.dbCollections.getIndexName(this.collection);
+        return {
+            'data-collection': this.collection,
+            'data-collectionId': indexName && data?.[indexName] !== undefined ? String(data?.[indexName]) : '',
+            'data-fieldName': String(fieldName),
+            'data-fieldType': fieldType,
+            'data-fieldArgs': fieldArgs
+        };
+    }
+    iterateArrayField(fieldName, data) {
+        return this.dbCollections.iterateArrayField(this.collection, fieldName, data);
+    }
+    iterateObjectField(fieldName, data) {
+        return this.dbCollections.iterateObjectField(this.collection, fieldName, data);
+    }
+    #formatNumberField(value) {
+        // Implement number formatting logic here
+        return value.toString();
+    }
+    #formatTextField(value, type) {
+        const lengths = {
+            'text-tiny': 10,
+            'text-short': 20,
+            'text-medium': 30,
+            'text-long': 40,
+            'text-giant': 50
+        };
+        const maxLength = lengths[type] || value.length;
+        return value.substring(0, maxLength);
+    }
+    #checkAccess() {
+        // Implement access check logic here
+        return true;
+    }
+    #checkError(condition, message, code) {
+        if (condition) {
+            IDbError.throwError(message, code);
+        }
+    }
+}
+export class IDbCollectionFieldValues {
+    #collection;
+    #collectionValues;
+    #data;
+    constructor(collection, data) {
+        this.#collection = collection;
+        this.#collectionValues = new IDbCollectionValues(collection);
+        this.#data = data;
+    }
+    format(fieldName) {
+        const fieldInfo = this.#collectionValues.dbCollections.parseCollectionFieldName(this.#collection, fieldName);
+        if (fieldInfo?.is === 'array') {
+            return this.iterateArray(String(fieldName), this.#data);
+        }
+        if (fieldInfo?.is === 'object') {
+            return this.iterateObject(String(fieldName), this.#data);
+        }
+        return this.#collectionValues.format(fieldName, this.#data);
+    }
+    getInputDataSet(fieldName) {
+        return this.#collectionValues.getInputDataSet(String(fieldName), this.#data);
+    }
+    // renamed from parseCollectionFieldName
+    getForge(fieldName) {
+        return this.#collectionValues.dbCollections.parseCollectionFieldName(this.#collection, String(fieldName));
+    }
+    iterateArray(fieldName, data) {
+        return this.#collectionValues.iterateArrayField(fieldName, data);
+    }
+    iterateObject(fieldName, data) {
+        return this.#collectionValues.iterateObjectField(fieldName, data);
+    }
+}
+/*
+    path: D:\boulot\python\wollama\src\lib\db\dbFields.ts
+    forge values for a collection field and $data
+ */
+export class IDbCollectionFieldForge {
+    #collection;
+    #collectionValues;
+    #fieldName;
+    #data;
+    #forge;
+    constructor(collection, fieldName, data) {
+        this.#collection = collection;
+        this.#collectionValues = new IDbCollectionValues(collection);
+        this.#fieldName = String(fieldName);
+        this.#data = data;
+    }
+    get format() {
+        return this.#collectionValues.format(String(this.#fieldName), this.#data);
+    }
+    get inputDataSet() {
+        return this.#collectionValues.getInputDataSet(String(this.#fieldName), this.#data);
+    }
+    // renamed from parseCollectionFieldName
+    get forge() {
+        return this.#collectionValues.dbCollections.parseCollectionFieldName(this.#collection, String(this.#fieldName));
+    }
+    get fieldArgs() {
+        return this.forge?.fieldArgs;
+    }
+    get fieldType() {
+        return this.forge?.fieldType;
+    }
+    /**
+     * will return  text.inputBase  for ['url', 'email', 'number', 'date', 'time', 'datetime', 'phone', 'password']
+     */
+    get htmlInputType() {
+        let variant = this?.fieldType?.split('text-')?.[1] ?? this.fieldType;
+        if (variant === 'area')
+            return variant;
+        if (this.forge?.fieldType?.startsWith('text-'))
+            return 'text';
+        if (['url', 'email', 'number', 'date', 'time', 'datetime', 'phone', 'password'].includes(this.forge?.fieldType ?? '')) {
+            return this.forge?.fieldType?.trim?.() ?? 'text';
+        }
+        return 'text';
+    }
+    get rawData() {
+        return this.#data;
+    }
+    iterateArray(fieldName, data) {
+        return this.#collectionValues.iterateArrayField(fieldName, data);
+    }
+    iterateObject(fieldName, data) {
+        return this.#collectionValues.iterateObjectField(fieldName, data);
+    }
+}
+class IDbValidationError extends Error {
+    field;
+    code;
+    constructor(field, code, message) {
+        super(message);
+        this.field = field;
+        this.code = code;
+        this.name = 'IDbValidationError';
+    }
+}
+export class IDbFormValidate {
+    collection;
+    dbFields;
+    constructor(collection) {
+        this.collection = collection;
+        this.dbFields = new IDbCollections();
+    }
+    validateField(fieldName, value) {
+        try {
+            const fieldInfo = this.dbFields.parseCollectionFieldName(this.collection, fieldName);
+            if (!fieldInfo) {
+                return { isValid: false, error: `Field ${String(fieldName)} not found in collection` };
+            }
+            // Vérification du type
+            if (!this.#validateType(value, fieldInfo.fieldType)) {
+                return this.#returnError(fieldName, fieldInfo.fieldType);
+            }
+            // Vérification des arguments du champ (required, etc.)
+            if (fieldInfo.fieldArgs) {
+                for (const arg of fieldInfo.fieldArgs) {
+                    if (arg === 'required' && (value === undefined || value === null || value === '')) {
+                        return this.#returnError(fieldName, 'required');
+                    }
+                }
+            }
+            // Validations spécifiques selon le type de champ
+            switch (fieldInfo.fieldType) {
+                case enumPrimitive.email:
+                    if (!this.validateEmail(value)) {
+                        return this.#returnError(fieldName, fieldInfo.fieldType);
+                    }
+                    break;
+                case enumPrimitive.url:
+                    if (!this.validateUrl(value)) {
+                        return this.#returnError(fieldName, fieldInfo.fieldType);
+                    }
+                    break;
+                case enumPrimitive.phone:
+                    if (!this.validatePhone(value)) {
+                        return this.#returnError(fieldName, fieldInfo.fieldType);
+                    }
+                    break;
+                case enumPrimitive.date:
+                case enumPrimitive.datetime:
+                case enumPrimitive.time:
+                    if (!this.validateDateTime(value, fieldInfo.fieldType)) {
+                        return this.#returnError(fieldName, fieldInfo.fieldType);
+                    }
+                    break;
+                // Ajoutez d'autres cas spécifiques ici
+            }
+            return { isValid: true };
+        }
+        catch (error) {
+            if (error instanceof IDbValidationError) {
+                return { isValid: false, error: error.message };
+            }
+            throw error;
+        }
+    }
+    validateFieldValue(fieldName, value) {
+        try {
+            this.validateField(fieldName, value);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    validateForm(formData, options = {}) {
+        const errors = {};
+        const invalidFields = [];
+        let isValid = true;
+        const fields = this.dbFields.getCollectionTemplateFields(this.collection);
+        if (!fields) {
+            return {
+                isValid: false,
+                errors: { general: 'Collection template not found' },
+                invalidFields: ['general']
+            };
+        }
+        for (const [fieldName, fieldRule] of Object.entries(fields)) {
+            // Ignorer les champs spécifiés dans options.ignoreFields
+            if (options.ignoreFields && options.ignoreFields.includes(fieldName)) {
+                continue;
+            }
+            const result = this.validateField(fieldName, formData[fieldName]);
+            if (!result.isValid) {
+                errors[fieldName] = result.error || 'Invalid field';
+                invalidFields.push(fieldName);
+                isValid = false;
+            }
+        }
+        return { isValid, errors, invalidFields };
+    }
+    #validateType(value, type) {
+        switch (type) {
+            case enumPrimitive.number:
+                return typeof value === 'number' && !isNaN(value);
+            case enumPrimitive.boolean:
+                return typeof value === 'boolean';
+            case enumPrimitive.text:
+            case enumPrimitive.email:
+            case enumPrimitive.url:
+            case enumPrimitive.phone:
+            case enumPrimitive.password:
+                return typeof value === 'string';
+            case enumPrimitive.date:
+            case enumPrimitive.datetime:
+            case enumPrimitive.time:
+                return value instanceof Date || typeof value === 'string';
+            case enumPrimitive.any:
+                return true;
+            default:
+                return true; // Pour les types non gérés, on considère que c'est valide
+        }
+    }
+    #returnError(fieldName, enumCode) {
+        throw new IDbValidationError(String(fieldName), enumCode ?? 'unknown', `Invalid format for field ${String(fieldName)}. Cause "${enumCode}" `);
+    }
+    validateEmail(email) {
+        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        return emailRegex.test(email);
+    }
+    validateUrl(url) {
+        try {
+            new URL(url);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    validatePhone(phone) {
+        // Ceci est un exemple simple. Vous pouvez ajuster selon vos besoins spécifiques
+        const phoneRegex = /^\+?[\d\s-]{10,}$/;
+        return phoneRegex.test(phone);
+    }
+    validateDateTime(value, type) {
+        const date = value instanceof Date ? value : new Date(value);
+        if (isNaN(date.getTime()))
+            return false;
+        switch (type) {
+            case enumPrimitive.date:
+                return true; // La conversion en Date a déjà validé le format
+            case enumPrimitive.time:
+                // Vérifiez si la chaîne contient uniquement l'heure
+                return /^([01]\d|2[0-3]):([0-5]\d)(:([0-5]\d))?$/.test(value);
+            case enumPrimitive.datetime:
+                return true; // La conversion en Date a déjà validé le format
+            default:
+                return false;
+        }
+    }
+}