jopi-toolkit 3.0.15 → 3.0.24

package/src/jk_fs/jBundler_ifServer.js

@@ -322,18 +322,53 @@ export function writeTextToFileSync(filePath, text, createDir) {
     }
     fss.writeFileSync(filePath, text, { encoding: 'utf8', flag: 'w' });
 }
-export function readTextFromFile(filePath) {
-    return fs.readFile(filePath, 'utf8');
+export function readTextFromFile(filePath_1) {
+    return __awaiter(this, arguments, void 0, function (filePath, throwError) {
+        var _a;
+        if (throwError === void 0) { throwError = false; }
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (throwError) {
+                        return [2 /*return*/, fs.readFile(filePath, 'utf8')];
+                    }
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, fs.readFile(filePath, 'utf8')];
+                case 2: return [2 /*return*/, _b.sent()];
+                case 3:
+                    _a = _b.sent();
+                    // @ts-ignore
+                    return [2 /*return*/, undefined];
+                case 4: return [2 /*return*/];
+            }
+        });
+    });
 }
-export function readJsonFromFile(filePath) {
-    return __awaiter(this, void 0, void 0, function () {
-        var txt;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, fs.readFile(filePath, 'utf8')];
+export function readJsonFromFile(filePath_1) {
+    return __awaiter(this, arguments, void 0, function (filePath, throwError) {
+        var txt, txt, _a;
+        if (throwError === void 0) { throwError = false; }
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (!throwError) return [3 /*break*/, 2];
+                    return [4 /*yield*/, fs.readFile(filePath, 'utf8')];
                 case 1:
-                    txt = _a.sent();
+                    txt = _b.sent();
                     return [2 /*return*/, JSON.parse(txt)];
+                case 2:
+                    _b.trys.push([2, 4, , 5]);
+                    return [4 /*yield*/, fs.readFile(filePath, 'utf8')];
+                case 3:
+                    txt = _b.sent();
+                    return [2 /*return*/, JSON.parse(txt)];
+                case 4:
+                    _a = _b.sent();
+                    // @ts-ignore
+                    return [2 /*return*/, undefined];
+                case 5: return [2 /*return*/];
             }
         });
     });

package/src/jk_fs/jBundler_ifServer.ts

@@ -181,13 +181,34 @@ export function writeTextToFileSync(filePath: string, text: string, createDir: b
     fss.writeFileSync(filePath, text, {encoding: 'utf8', flag: 'w'});
 }
 
-export function readTextFromFile(filePath: string): Promise<string> {
-    return fs.readFile(filePath, 'utf8');
+export async function readTextFromFile(filePath: string, throwError: boolean = false): Promise<string> {
+    if (throwError) {
+        return fs.readFile(filePath, 'utf8');
+    }
+
+    try {
+        return await fs.readFile(filePath, 'utf8');
+    }
+    catch {
+        // @ts-ignore
+        return undefined;
+    }
 }
 
-export async function readJsonFromFile<T = any>(filePath: string): Promise<T> {
-    let txt = await fs.readFile(filePath, 'utf8');
-    return JSON.parse(txt) as T;
+export async function readJsonFromFile<T = any>(filePath: string, throwError: boolean = false): Promise<T> {
+    if (throwError) {
+        let txt = await fs.readFile(filePath, 'utf8');
+        return JSON.parse(txt) as T;
+    } else {
+        try {
+            let txt = await fs.readFile(filePath, 'utf8');
+            return JSON.parse(txt) as T;
+        }
+        catch {
+            // @ts-ignore
+            return undefined;
+        }
+    }
 }
 
 export function readTextFromFileSync(filePath: string): string {

package/src/jk_schemas/index.js

@@ -54,7 +54,7 @@ export function validateSchema(data, schema) {
     //
     if (schema.schemaMeta.normalize) {
         try {
-            schema.schemaMeta.normalize(data);
+            schema.schemaMeta.normalize(data, gValueCheckingHelper);
         }
         catch (e) {
             if (e instanceof SchemaError) {
@@ -81,7 +81,7 @@ export function validateSchema(data, schema) {
             var value = data[fieldName];
             if (field.normalize) {
                 defaultErrorMessage = field.errorMessage_theValueIsInvalid;
-                field.normalize(value, data);
+                field.normalize(value, data, gValueCheckingHelper);
             }
             if (!field.optional) {
                 if (value === undefined) {
@@ -102,7 +102,7 @@ export function validateSchema(data, schema) {
             }
             if (field.validator) {
                 defaultErrorMessage = field.errorMessage_theValueIsInvalid;
-                field.validator(value, data);
+                field.validator(value, data, gValueCheckingHelper);
             }
         }
         catch (e) {
@@ -124,7 +124,7 @@ export function validateSchema(data, schema) {
     //     Allow validating if values are ok with each others.
     if (schema.schemaMeta.validate) {
         try {
-            schema.schemaMeta.validate(data);
+            schema.schemaMeta.validate(data, gValueCheckingHelper);
         }
         catch (e) {
             if (e instanceof SchemaError) {
@@ -147,6 +147,19 @@ export function validateSchema(data, schema) {
     return { fields: fieldErrors };
 }
 var byTypeValidator = {};
+/**
+ * A helper allowing to make field validation easier.
+ * Is sent to normalize and validate functions.
+ */
+var ValueCheckingHelper = /** @class */ (function () {
+    function ValueCheckingHelper() {
+    }
+    ValueCheckingHelper.prototype.declareError = function (message, errorCode) {
+        throw new SchemaError(message, errorCode);
+    };
+    return ValueCheckingHelper;
+}());
+var gValueCheckingHelper = new ValueCheckingHelper();
 export function registerSchema(schemaId, schema, meta) {
     if (!schemaId) {
         throw new Error("jk_schemas - Schema id required. If you need an uid you can use: " + generateUUIDv4());
@@ -176,8 +189,40 @@ var gRegistry = {};
 //endregion
 //region Schema
 export function schema(descriptor, meta) {
-    return { desc: descriptor, schemaMeta: meta || {} };
+    return new SchemaImpl(descriptor, meta || {});
 }
+var SchemaImpl = /** @class */ (function () {
+    function SchemaImpl(desc, schemaMeta) {
+        this.desc = desc;
+        this.schemaMeta = schemaMeta;
+    }
+    SchemaImpl.prototype.toJson = function () {
+        return toJson(this);
+    };
+    SchemaImpl.prototype.addDataNormalizer = function (f) {
+        if (!this.schemaMeta.normalize) {
+            this.schemaMeta.normalize = f;
+        }
+        var f1 = this.schemaMeta.normalize;
+        this.schemaMeta.normalize = function (values, helper) {
+            f1(values, helper);
+            f(values, helper);
+        };
+        return this;
+    };
+    SchemaImpl.prototype.addDataValidator = function (f) {
+        if (!this.schemaMeta.validate) {
+            this.schemaMeta.validate = f;
+        }
+        var f1 = this.schemaMeta.validate;
+        this.schemaMeta.validate = function (values, helper) {
+            f1(values, helper);
+            f(values, helper);
+        };
+        return this;
+    };
+    return SchemaImpl;
+}());
 export function toJson(schema) {
     return schema;
 }

package/src/jk_schemas/index.ts

@@ -47,7 +47,7 @@ export function validateSchema(data: any, schema: Schema): ValidationErrors|unde
     //
     if (schema.schemaMeta.normalize) {
         try {
-            schema.schemaMeta.normalize(data);
+            schema.schemaMeta.normalize(data, gValueCheckingHelper);
         }
         catch (e: any) {
             if (e instanceof SchemaError) {
@@ -80,7 +80,7 @@ export function validateSchema(data: any, schema: Schema): ValidationErrors|unde
 
             if (field.normalize) {
                 defaultErrorMessage = field.errorMessage_theValueIsInvalid;
-                field.normalize(value, data);
+                field.normalize(value, data, gValueCheckingHelper);
             }
 
             if (!field.optional) {
@@ -103,7 +103,7 @@ export function validateSchema(data: any, schema: Schema): ValidationErrors|unde
 
             if (field.validator) {
                 defaultErrorMessage = field.errorMessage_theValueIsInvalid;
-                field.validator(value, data);
+                field.validator(value, data, gValueCheckingHelper);
             }
         }
         catch (e: any) {
@@ -126,7 +126,7 @@ export function validateSchema(data: any, schema: Schema): ValidationErrors|unde
 
     if (schema.schemaMeta.validate) {
         try {
-            schema.schemaMeta.validate(data);
+            schema.schemaMeta.validate(data, gValueCheckingHelper);
         }
         catch (e: any) {
             if (e instanceof SchemaError) {
@@ -151,6 +151,18 @@ export function validateSchema(data: any, schema: Schema): ValidationErrors|unde
 
 const byTypeValidator: Record<string, (v: any, fieldInfos: SchemaFieldInfos) => void> = {};
 
+/**
+ * A helper allowing to make field validation easier.
+ * Is sent to normalize and validate functions.
+ */
+class ValueCheckingHelper {
+    declareError(message?: string, errorCode?: string) {
+        throw new SchemaError(message, errorCode);
+    }
+}
+
+const gValueCheckingHelper = new ValueCheckingHelper();
+
 //endregion
 
 //region Registry
@@ -197,11 +209,50 @@ const gRegistry: Record<string, RegistryEntry> = {};
 //region Schema
 
 export function schema<T extends SchemaDescriptor>(descriptor: T, meta?: SchemaMeta): Schema & { desc: T } {
-    return { desc: descriptor, schemaMeta: meta || {} };
+    return new SchemaImpl(descriptor, meta || {});
+}
+
+class SchemaImpl<T extends SchemaDescriptor> implements Schema {
+    constructor(public readonly desc: T, public readonly schemaMeta: SchemaMeta) {
+    }
+
+    toJson(): SchemaInfo {
+        return toJson(this);
+    }
+
+    addDataNormalizer(f: (allValues: any, checkHelper: ValueCheckingHelper) => void): this {
+        if (!this.schemaMeta.normalize) {
+            this.schemaMeta.normalize = f;
+        }
+
+        const f1 = this.schemaMeta.normalize;
+
+        this.schemaMeta.normalize = function (values, helper) {
+            f1(values, helper);
+            f(values, helper);
+        }
+        
+        return this;
+    }
+
+    addDataValidator(f: (allValues: any, checkHelper: ValueCheckingHelper) => void): this {
+        if (!this.schemaMeta.validate) {
+            this.schemaMeta.validate = f;
+        }
+
+        const f1 = this.schemaMeta.validate;
+
+        this.schemaMeta.validate = function (values, helper) {
+            f1(values, helper);
+            f(values, helper);
+        }
+        
+        return this;
+    }
 }
 
 export interface SchemaDescriptor  {
-    [field: string]: ScField<any, any>;
+    [field: string]: Field;
 }
 
 export interface SchemaMeta {
@@ -209,8 +260,8 @@ export interface SchemaMeta {
     description?: string;
     [key: string]: any;
     
-    normalize?: (allValues: any) => void;
-    validate?: (allValues: any) => void;
+    normalize?: (allValues: any, checkHelper: ValueCheckingHelper) => void;
+    validate?: (allValues: any, checkHelper: ValueCheckingHelper) => void;
 }
 
 export interface SchemaInfo {
@@ -219,6 +270,26 @@ export interface SchemaInfo {
 }
 
 export interface Schema extends SchemaInfo {
+    /**
+     * Get serializable data describing this schema.
+     */
+    toJson(): SchemaInfo;
+
+    /**
+     * Add a function whose role is to normalize the data.
+     *
+     * Cumulating: if a normalize function has already been added,
+     * then the previous function will be called before this one.
+     */
+    addDataNormalizer(f: (allValues: any, checkHelper: ValueCheckingHelper) => void): this;
+
+    /**
+     * Add a function whose role is to validate the data.
+     *
+     * Cumulating: if a validate function has already been added,
+     * then the previous function will be called before this one.
+     */
+    addDataValidator(f: (allValues: any, checkHelper: ValueCheckingHelper) => void): this;
 }
 
 export function toJson(schema: Schema): SchemaInfo {
@@ -304,7 +375,46 @@ export interface ScOnTableRenderingInfo {
     textAlign?: "left" | "center" | "right";
 }
 
-interface ScField<T, Opt extends boolean> {
+/**
+ * Get information about how storing this field.
+ */
+export interface ScFieldStore {
+    /**
+     * Allow knowing if a BDD index must be created for this field.
+     * The default is true.
+     */
+    mustIndex?: boolean;
+
+    /**
+     * Allow knowing if this field is the primary key.
+     * If more than one primary is set, then a composed key will be created.
+     * The default is false.
+     */
+    isPrimaryKey?: boolean;
+
+    /**
+     * The column name to use when storing this field in a database.
+     * The default is the field name.
+     */
+    colName?: string;
+
+    /**
+     * An indication on the size of the data to store.
+     * The default is "default".
+     *
+     * - big: for storing large strings / binary.
+     * - medium: for storing item with a common size.
+     * - tiny: for storing small strings / binary.
+     */
+    dataSize?: "tiny" | "medium" | "big";
+
+    /**
+     * Allow forcing the type name for the BDD.
+     */
+    databaseType?: string;
+}
+
+export interface ScField<T, Opt extends boolean> {
     title: string;
     type: string;
 
@@ -316,12 +426,31 @@ interface ScField<T, Opt extends boolean> {
     errorMessage_theDataTypeIsInvalid?: string;
     errorMessage_theValueIsInvalid?: string;
 
-    normalize?: (value: T, allValues: any) => void;
-    validator?: (value: T, allValues: any) => void;
+    /**
+     * A function used to normalize the field value.
+     */
+    normalize?: (value: T, allValues: any, valueCheckingHelp: ValueCheckingHelper) => void;
+
+    /**
+     * A function used to validate the field.
+     */
+    validator?: (value: T, allValues: any, valueCheckingHelp: ValueCheckingHelper) => void;
 
+    /**
+     * Meta-data associated with this field.
+     * The usage is free, you can use it for whatever you want.
+     */
     metas?: Record<string, string>;
 
+    /**
+     * Get information about how to render this field in a data table.
+     */
     onTableRendering?: ScOnTableRenderingInfo;
+
+    /**
+     * Get information about how storing this field.
+     */
+    store?: ScFieldStore;
 }
 
 export type Field = ScField<any, any>;

package/src/jk_term/index.js

@@ -114,6 +114,8 @@ export var logBgRed = buildLogger(B_RED);
 export var textBgRed = buildWriter(B_RED);
 export var logBlue = buildLogger(C_BLUE);
 export var textBlue = buildWriter(C_BLUE);
+export var logGrey = buildLogger(C_GREY);
+export var textGrey = buildWriter(C_GREY);
 export var logBgBlue = buildLogger(B_BLUE, C_WHITE);
 export var textBgBlue = buildWriter(B_BLUE, C_WHITE);
 export var logGreen = buildLogger(C_GREEN);

package/src/jk_term/index.ts

@@ -105,6 +105,9 @@ export const textBgRed = buildWriter(B_RED);
 export const logBlue = buildLogger(C_BLUE);
 export const textBlue = buildWriter(C_BLUE);
 
+export const logGrey = buildLogger(C_GREY);
+export const textGrey = buildWriter(C_GREY);
+
 export const logBgBlue = buildLogger(B_BLUE, C_WHITE);
 export const textBgBlue = buildWriter(B_BLUE, C_WHITE);
 

package/dist/jk_schemas/jkSchemas.d.ts

@@ -1,188 +0,0 @@
-/**
- * Declare an error when validating a schema.
- * Must be called when validating or normalizing.
- */
-export declare function declareError(message?: string, errorCode?: string): void;
-export interface FieldError {
-    fieldName: string;
-    message: string;
-    code?: string;
-}
-export interface ValidationErrors {
-    /**
-     * An error about the whole schema.
-     */
-    globalError?: string;
-    globalErrorCode?: string;
-    /**
-     * An error per field.
-     */
-    fields?: Record<string, FieldError>;
-}
-export declare function validateSchema(data: any, schema: Schema): ValidationErrors | undefined;
-export declare function registerSchema(schemaId: string | undefined, schema: Schema, meta?: any): void;
-export declare function getSchemaMeta(schemaId: string): Schema | undefined;
-export declare function getSchema(schemaId: string): Schema | undefined;
-export declare function requireSchema(schemaId: string): Schema;
-export declare function schema<T extends SchemaDescriptor>(descriptor: T, meta?: SchemaMeta): Schema & {
-    desc: T;
-};
-export interface SchemaDescriptor {
-    [field: string]: ScField<any, any>;
-}
-export interface SchemaMeta {
-    title?: string;
-    description?: string;
-    [key: string]: any;
-    normalize?: (allValues: any) => void;
-    validate?: (allValues: any) => void;
-}
-export interface SchemaInfo {
-    desc: SchemaDescriptor;
-    schemaMeta: SchemaMeta;
-}
-export interface Schema extends SchemaInfo {
-}
-export declare function toJson(schema: Schema): SchemaInfo;
-/**
- * Allow getting a valid TypeScript type for our schema.
- *
- * **Example**
- * ```
- * const UserSchema = { name: string("The name", false), test: string("Test", true) };
- * type UserDataType = SchemaToType<typeof UserSchema>;
- * let ud: UserDataType = {name:"ok", test: "5"};
- * ```
- */
-export type SchemaToType<S extends Schema> = {
-    [K in keyof S['desc'] as S['desc'][K] extends ScField<any, false> ? K : never]: S['desc'][K] extends ScField<infer T, any> ? T : never;
-} & {
-    [K in keyof S['desc'] as S['desc'][K] extends ScField<any, true> ? K : never]?: S['desc'][K] extends ScField<infer T, any> ? T : never;
-};
-export interface ScOnTableRenderingInfo {
-    /**
-     * The title to use if rendering with a Table.
-     */
-    title?: string;
-    /**
-     * If true, then allows hiding the column
-     * when rendering into a UI table component.
-     */
-    enableHiding?: boolean;
-    /**
-     * If true, then the table column is hidden by default.
-     */
-    defaultHidden?: boolean;
-    /**
-     * If true, then the table column is hidden and remain hidden.
-     */
-    alwaysHidden?: boolean;
-    /**
-     * If true, then allows sorting the column
-     * when rendering into a UI table component.
-     */
-    enableSorting?: boolean;
-    /**
-     * If true, then allows editing the column
-     * when rendering into a UI table component.
-     */
-    enableEditing?: boolean;
-    /**
-     * Contains the name of the renderer to user for the header.
-     */
-    rendererForHeader?: string;
-    /**
-     * Contains the name of the renderer to user for the cell.
-     */
-    rendererForCell?: string;
-    /**
-     * Allows setting the column grow rule.
-     */
-    columnGrow?: "takeAllPlace" | "takeMinPlace";
-    /**
-     * Allows defining extra-css class for rendering the cells.
-     */
-    cellCssClass?: string;
-    /**
-     * Allows defining extra-css class for rendering the header.
-     */
-    headerCssClass?: string;
-    textAlign?: "left" | "center" | "right";
-}
-interface ScField<T, Opt extends boolean> {
-    title: string;
-    type: string;
-    description?: string;
-    default?: T;
-    optional?: Opt;
-    errorMessage_isRequired?: string;
-    errorMessage_theDataTypeIsInvalid?: string;
-    errorMessage_theValueIsInvalid?: string;
-    normalize?: (value: T, allValues: any) => void;
-    validator?: (value: T, allValues: any) => void;
-    metas?: Record<string, string>;
-    onTableRendering?: ScOnTableRenderingInfo;
-}
-export type Field = ScField<any, any>;
-export type SchemaFieldInfos = Field;
-type OnlyInfos<T> = Omit<T, "title" | "optional" | "type">;
-export interface ScString<Opt extends boolean = boolean> extends ScField<string, Opt> {
-    minLength?: number;
-    errorMessage_minLength?: string;
-    maxLength?: number;
-    errorMessage_maxLength?: string;
-    placeholder?: string;
-}
-export declare function string<Opt extends boolean>(title: string, optional: Opt, infos?: OnlyInfos<ScString<Opt>>): ScString<Opt>;
-export interface ScBoolean<Opt extends boolean = boolean> extends ScField<boolean, Opt> {
-    requireTrue?: boolean;
-    errorMessage_requireTrue?: string;
-    requireFalse?: boolean;
-    errorMessage_requireFalse?: string;
-}
-export declare function boolean<Opt extends boolean>(title: string, optional: Opt, infos?: OnlyInfos<ScBoolean<Opt>>): ScBoolean<Opt>;
-export interface ScNumber<Opt extends boolean = boolean> extends ScField<number, Opt> {
-    minValue?: number;
-    errorMessage_minValue?: string;
-    maxValue?: number;
-    errorMessage_maxValue?: string;
-    allowDecimal?: boolean;
-    roundMethod?: "round" | "floor" | "ceil";
-    errorMessage_dontAllowDecimal?: string;
-    incrStep?: number;
-    placeholder?: string;
-    /**
-     * Allows displaying this value as a simple
-     * number, or a current, or a percent.
-     */
-    displayType?: "decimal" | "currency" | "percent";
-    /**
-     * The regional currency format to use for formating.
-     * Ex: "en-US", "fr-FR".
-     */
-    localFormat?: string;
-    /**
-     * The type of currency.
-     * Ex: "USD".
-     */
-    currency?: string;
-}
-export declare function number<Opt extends boolean>(title: string, optional: Opt, infos?: OnlyInfos<ScNumber<Opt>>): ScNumber<Opt>;
-export declare function formatNumber(value: string, fieldNumber: ScNumber, defaultLocalFormat?: string, defaultCurrency?: string): string;
-export declare function currency<Opt extends boolean>(title: string, optional: Opt, infos?: OnlyInfos<ScNumber<Opt>>): ScNumber<Opt>;
-export declare function percent<Opt extends boolean>(title: string, optional: Opt, infos?: OnlyInfos<ScNumber<Opt>>): ScNumber<Opt>;
-export interface File extends Blob {
-    readonly lastModified: number;
-    readonly name: string;
-    readonly webkitRelativePath: string;
-}
-export interface ScFile<Opt extends boolean> extends ScField<File[], Opt> {
-    maxFileCount?: number;
-    errorMessage_maxFileCount?: string;
-    acceptFileType?: string;
-    errorMessage_invalidFileType?: string;
-    maxFileSize?: number;
-    errorMessage_maxFileSize?: string;
-}
-export declare function file<Opt extends boolean>(title: string, optional: Opt, infos?: OnlyInfos<ScFile<Opt>>): ScFile<Opt>;
-export {};