jopi-toolkit 3.0.5

package/src/jk_schemas/index.js

@@ -0,0 +1,248 @@
+// noinspection JSUnusedGlobalSymbols
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { generateUUIDv4 } from "jopi-toolkit/jk_tools";
+//region Validation
+/**
+ * Throwing this error allows it to be caught
+ * when validating an object.
+ */
+var SchemaError = /** @class */ (function (_super) {
+    __extends(SchemaError, _super);
+    function SchemaError(errorMessage, errorCode) {
+        var _this = _super.call(this, "") || this;
+        _this.errorMessage = errorMessage;
+        _this.errorCode = errorCode;
+        return _this;
+    }
+    return SchemaError;
+}(Error));
+/**
+ * Declare an error when validating a schema.
+ * Must be called when validating or normalizing.
+ */
+export function declareError(message, errorCode) {
+    throw new SchemaError(message, errorCode);
+}
+var byTypeValidator = {
+    "string": function (v, f) {
+        if (typeof v !== "string") {
+            declareError(f.errorMessage_theValueIsInvalid || "Value must be a string", "INVALID_TYPE");
+            return;
+        }
+        var sf = f;
+        if ((sf.minLength !== undefined) && (v.length < sf.minLength)) {
+            declareError(sf.errorMessage_minLength || "Value must be at least ".concat(sf.minLength, " characters long"), "INVALID_LENGTH");
+            return;
+        }
+        if ((sf.maxLength !== undefined) && (v.length > sf.maxLength)) {
+            declareError(sf.errorMessage_maxLength || "Value must be less than ".concat(sf.maxLength, " characters long"), "INVALID_LENGTH");
+            return;
+        }
+    },
+    "number": function (v, f) {
+        if (typeof v !== "number") {
+            declareError(f.errorMessage_theValueIsInvalid || "Value must be a number", "INVALID_TYPE");
+        }
+        var sf = f;
+        if ((sf.minValue !== undefined) && (v < sf.minValue)) {
+            declareError(sf.errorMessage_minValue || "Value must be at least ".concat(sf.minValue), "INVALID_LENGTH");
+            return;
+        }
+        if ((sf.maxValue !== undefined) && (v > sf.maxValue)) {
+            declareError(sf.errorMessage_maxValue || "Value must be less than ".concat(sf.maxValue), "INVALID_LENGTH");
+            return;
+        }
+    },
+    "boolean": function (v, f) {
+        if (typeof v !== "boolean") {
+            declareError(f.errorMessage_theValueIsInvalid || "Value must be a boolean", "INVALID_TYPE");
+        }
+        var sf = f;
+        if (sf.requireTrue) {
+            if (v !== true) {
+                declareError(sf.errorMessage_requireTrue || "Value must be true", "INVALID_VALUE");
+            }
+        }
+        else if (sf.requireFalse) {
+            if (v !== false) {
+                declareError(sf.errorMessage_requireFalse || "Value must be false", "INVALID_VALUE");
+            }
+        }
+    }
+};
+export function validateSchema(data, schema) {
+    if (schema.schemaMeta.normalize) {
+        try {
+            schema.schemaMeta.normalize(data);
+        }
+        catch (e) {
+            if (e instanceof SchemaError) {
+                return {
+                    globalError: e.errorMessage || "Schema validation failed",
+                    globalErrorCode: e.errorCode || "SCHEMA_VALIDATION_FAILED"
+                };
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    var fieldErrors;
+    for (var fieldName in schema.desc) {
+        var defaultErrorMessage = void 0;
+        try {
+            var field = schema.desc[fieldName];
+            var value = data[fieldName];
+            if (field.normalize) {
+                defaultErrorMessage = field.errorMessage_theValueIsInvalid;
+                field.normalize(value, data);
+            }
+            if (!field.optional) {
+                if (value === undefined) {
+                    if (field.errorMessage_isRequired) {
+                        declareError(field.errorMessage_isRequired, "VALUE_REQUIRED");
+                    }
+                    else if (field.errorMessage_theValueIsInvalid) {
+                        declareError(field.errorMessage_theValueIsInvalid, "VALUE_REQUIRED");
+                    }
+                    else {
+                        declareError("Field ".concat(fieldName, " is required"), "VALUE_REQUIRED");
+                    }
+                }
+            }
+            var typeValidator = byTypeValidator[field.type];
+            if (typeValidator) {
+                typeValidator(value, field);
+            }
+            if (field.validator) {
+                defaultErrorMessage = field.errorMessage_theValueIsInvalid;
+                field.validator(value, data);
+            }
+        }
+        catch (e) {
+            if (e instanceof SchemaError) {
+                if (!fieldErrors)
+                    fieldErrors = {};
+                fieldErrors[fieldName] = {
+                    fieldName: fieldName,
+                    message: e.errorMessage || defaultErrorMessage || "Field ".concat(fieldName, " is invalid"),
+                    code: e.errorCode || "FIELD_VALIDATION_FAILED"
+                };
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    if (schema.schemaMeta.validate) {
+        try {
+            schema.schemaMeta.validate(data);
+        }
+        catch (e) {
+            if (e instanceof SchemaError) {
+                return {
+                    globalError: e.errorMessage || "Schema validation failed",
+                    globalErrorCode: e.errorCode || "SCHEMA_VALIDATION_FAILED",
+                    fields: fieldErrors
+                };
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    if (!fieldErrors)
+        return undefined;
+    return { fields: fieldErrors };
+}
+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());
+    }
+    gRegistry[schemaId] = { schema: schema, meta: meta };
+}
+export function getSchemaMeta(schemaId) {
+    var entry = gRegistry[schemaId];
+    if (entry)
+        return entry.schema;
+    return undefined;
+}
+export function getSchema(schemaId) {
+    var entry = gRegistry[schemaId];
+    if (entry)
+        return entry.schema;
+    return undefined;
+}
+export function requireSchema(schemaId) {
+    var s = getSchema(schemaId);
+    if (!s) {
+        throw new Error("jk_schemas - Schema ".concat(schemaId, " not found"));
+    }
+    return s;
+}
+var gRegistry = {};
+//endregion
+//region Schema
+export function schema(descriptor, meta) {
+    return { desc: descriptor, schemaMeta: meta || {} };
+}
+export function toJson(schema) {
+    return schema;
+}
+export function string(title, optional, infos) {
+    if (!optional) {
+        if (!infos)
+            infos = {};
+        if (infos.minLength === undefined)
+            infos.minLength = 1;
+    }
+    return __assign(__assign({}, infos), { title: title, optional: optional, type: "string" });
+}
+export function boolean(title, optional, infos) {
+    return __assign(__assign({}, infos), { title: title, optional: optional, type: "boolean" });
+}
+export function number(title, optional, infos) {
+    return __assign(__assign({}, infos), { title: title, optional: optional, type: "number" });
+}
+export function file(title, optional, infos) {
+    return __assign(__assign({}, infos), { title: title, optional: optional, type: "file" });
+}
+//endregion
+//endregion
+/*const MAKE_OPTIONAL = true;
+//
+const UserSchema1 = schema({
+    testOptional: string("testOptional", true),
+    testString: string("testString", MAKE_OPTIONAL),
+    testBool: boolean("testBool", MAKE_OPTIONAL),
+    testNumber: number("testNumber", MAKE_OPTIONAL),
+    testFile: file("testFile", MAKE_OPTIONAL)
+})
+
+type UserDataType1 = SchemaToType<typeof UserSchema1>;
+let ud1: UserDataType1 = {};*/ 

package/src/jk_schemas/index.ts

@@ -0,0 +1,416 @@
+// noinspection JSUnusedGlobalSymbols
+
+import {generateUUIDv4} from "jopi-toolkit/jk_tools";
+
+//region Validation
+
+/**
+ * Throwing this error allows it to be caught
+ * when validating an object.
+ */
+class SchemaError extends Error {
+    constructor(public readonly errorMessage?: string, public readonly errorCode?: string) {
+        super("");
+    }
+}
+
+/**
+ * Declare an error when validating a schema.
+ * Must be called when validating or normalizing.
+ */
+export function declareError(message?: string, errorCode?: string) {
+    throw new SchemaError(message, errorCode);
+}
+
+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>;
+}
+
+const byTypeValidator: Record<string, (v: any, fieldInfos: SchemaFieldInfos) => void> = {
+    "string": (v, f) => {
+        if (typeof v !== "string") {
+            declareError(f.errorMessage_theValueIsInvalid || `Value must be a string`, "INVALID_TYPE");
+            return;
+        }
+
+        let sf = f as ScString<any>;
+
+        if ((sf.minLength!==undefined) && (v.length < sf.minLength)) {
+            declareError(sf.errorMessage_minLength || `Value must be at least ${sf.minLength} characters long`, "INVALID_LENGTH");
+            return;
+        }
+
+        if ((sf.maxLength!==undefined) && (v.length > sf.maxLength)) {
+            declareError(sf.errorMessage_maxLength || `Value must be less than ${sf.maxLength} characters long`, "INVALID_LENGTH");
+            return;
+        }
+    },
+
+    "number": (v, f) => {
+        if (typeof v !== "number") {
+            declareError(f.errorMessage_theValueIsInvalid || `Value must be a number`, "INVALID_TYPE");
+        }
+
+        let sf = f as ScNumber<any>;
+
+        if ((sf.minValue!==undefined) && (v < sf.minValue)) {
+            declareError(sf.errorMessage_minValue || `Value must be at least ${sf.minValue}`, "INVALID_LENGTH");
+            return;
+        }
+
+        if ((sf.maxValue!==undefined) && (v > sf.maxValue)) {
+            declareError(sf.errorMessage_maxValue || `Value must be less than ${sf.maxValue}`, "INVALID_LENGTH");
+            return;
+        }
+    },
+
+    "boolean": (v, f) => {
+        if (typeof v !== "boolean") {
+            declareError(f.errorMessage_theValueIsInvalid || `Value must be a boolean`, "INVALID_TYPE");
+        }
+
+        let sf = f as ScBoolean<any>;
+        
+        if (sf.requireTrue) {
+            if (v!==true) {
+                declareError(sf.errorMessage_requireTrue || `Value must be true`, "INVALID_VALUE");
+            }
+        } else if (sf.requireFalse) {
+            if (v!==false) {
+                declareError(sf.errorMessage_requireFalse || `Value must be false`, "INVALID_VALUE");
+            }
+        }
+    }
+}
+
+export function validateSchema(data: any, schema: Schema): ValidationErrors|undefined {
+    if (schema.schemaMeta.normalize) {
+        try {
+            schema.schemaMeta.normalize(data);
+        }
+        catch (e: any) {
+            if (e instanceof SchemaError) {
+                return {
+                    globalError: e.errorMessage || `Schema validation failed`,
+                    globalErrorCode: e.errorCode || "SCHEMA_VALIDATION_FAILED"
+                };
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+
+    let fieldErrors: Record<string, FieldError>|undefined;
+
+    for (let fieldName in schema.desc) {
+        let defaultErrorMessage: string|undefined;
+
+        try {
+            const field = schema.desc[fieldName];
+            const value = data[fieldName];
+
+            if (field.normalize) {
+                defaultErrorMessage = field.errorMessage_theValueIsInvalid;
+                field.normalize(value, data);
+            }
+
+            if (!field.optional) {
+                if (value === undefined) {
+                    if (field.errorMessage_isRequired) {
+                        declareError(field.errorMessage_isRequired, "VALUE_REQUIRED");
+                    } else if (field.errorMessage_theValueIsInvalid) {
+                        declareError(field.errorMessage_theValueIsInvalid, "VALUE_REQUIRED");
+                    } else {
+                        declareError(`Field ${fieldName} is required`, "VALUE_REQUIRED");
+                    }
+                }
+            }
+
+            let typeValidator = byTypeValidator[field.type];
+
+            if (typeValidator) {
+                typeValidator(value, field);
+            }
+
+            if (field.validator) {
+                defaultErrorMessage = field.errorMessage_theValueIsInvalid;
+                field.validator(value, data);
+            }
+        }
+        catch (e: any) {
+            if (e instanceof SchemaError) {
+                if (!fieldErrors) fieldErrors = {};
+
+                fieldErrors[fieldName] = {
+                    fieldName,
+                    message: e.errorMessage || defaultErrorMessage || `Field ${fieldName} is invalid`,
+                    code: e.errorCode || "FIELD_VALIDATION_FAILED"
+                };
+            } else {
+                throw e;
+            }
+        }
+    }
+
+    if (schema.schemaMeta.validate) {
+        try {
+            schema.schemaMeta.validate(data);
+        }
+        catch (e: any) {
+            if (e instanceof SchemaError) {
+                return {
+                    globalError: e.errorMessage || `Schema validation failed`,
+                    globalErrorCode: e.errorCode || "SCHEMA_VALIDATION_FAILED",
+                    fields: fieldErrors
+                };
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+
+    if (!fieldErrors) return undefined;
+    return {fields: fieldErrors};
+}
+
+//endregion
+
+//region Registry
+
+interface RegistryEntry {
+    schema: Schema;
+    meta?: any;
+}
+
+export function registerSchema(schemaId: string|undefined, schema: Schema, meta?: any) {
+    if (!schemaId) {
+        throw new Error("jk_schemas - Schema id required. If you need an uid you can use: " + generateUUIDv4());
+    }
+
+    gRegistry[schemaId!] = {schema, meta};
+}
+
+export function getSchemaMeta(schemaId: string): Schema|undefined {
+    const entry = gRegistry[schemaId];
+    if (entry) return entry.schema;
+    return undefined;
+}
+
+export function getSchema(schemaId: string): Schema|undefined {
+    const entry = gRegistry[schemaId];
+    if (entry) return entry.schema;
+    return undefined;
+}
+
+export function requireSchema(schemaId: string): Schema {
+    const s = getSchema(schemaId);
+
+    if (!s) {
+        throw new Error(`jk_schemas - Schema ${schemaId} not found`);
+    }
+
+    return s;
+}
+
+const gRegistry: Record<string, RegistryEntry> = {};
+
+//endregion
+
+//region Schema
+
+export function schema<T extends SchemaDescriptor>(descriptor: T, meta?: SchemaMeta): Schema & { desc: T } {
+    return { desc: descriptor, schemaMeta: meta || {} };
+}
+
+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 function toJson(schema: Schema): SchemaInfo {
+    return schema;
+}
+
+/**
+ * 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> =
+// 1. On accède au descripteur de schéma S['desc']
+// 2. On itère sur ses clés K
+// 3. On filtre les champs obligatoires (Opt = false)
+    { [K in keyof S['desc'] as S['desc'][K] extends ScField<any, false> ? K : never]:
+        // 4. On infère le type T du champ
+        S['desc'][K] extends ScField<infer T, any> ? T : never }
+
+    // 5. On fusionne avec les champs optionnels (Opt = true)
+    & { [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 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>;
+}
+
+export type SchemaFieldInfos = ScField<any, any>;
+
+type OnlyInfos<T> = Omit<Omit<Omit<T, "title">, "optional">, "type">;
+
+//endregion
+
+//region Common types
+
+//region String
+
+export interface ScString<Opt extends boolean> extends ScField<string, Opt> {
+    minLength?: number;
+    errorMessage_minLength?: string;
+
+    maxLength?: number;
+    errorMessage_maxLength?: string;
+
+    placeholder?: string;
+}
+
+export function string<Opt extends boolean>(title: string, optional: Opt, infos?: OnlyInfos<ScString<Opt>>): ScString<Opt> {
+    if (!optional) {
+        if (!infos) infos = {};
+        if (infos.minLength===undefined) infos.minLength = 1;
+    }
+
+    return {...infos, title, optional, type: "string"};
+}
+
+//endregion
+
+//region Boolean
+
+export interface ScBoolean<Opt extends boolean> extends ScField<boolean, Opt> {
+    requireTrue?: boolean;
+    errorMessage_requireTrue?: string;
+    
+    requireFalse?: boolean;
+    errorMessage_requireFalse?: string;
+}
+
+export function boolean<Opt extends boolean>(title: string, optional: Opt, infos?: OnlyInfos<ScBoolean<Opt>>): ScBoolean<Opt> {
+    return {...infos, title, optional, type: "boolean"};
+}
+
+//endregion
+
+//region Number
+
+export interface ScNumber<Opt extends boolean> extends ScField<number, Opt> {
+    minValue?: number;
+    errorMessage_minValue?: string;
+
+    maxValue?: number;
+    errorMessage_maxValue?: string;
+
+    // TODO: allowDecimal
+    allowDecimal?: boolean;
+    roundMethod?: "round" | "floor" | "ceil";
+    errorMessage_dontAllowDecimal?: string;
+
+    incrStep?: number;
+    placeholder?: string;
+}
+
+export function number<Opt extends boolean>(title: string, optional: Opt, infos?: OnlyInfos<ScNumber<Opt>>): ScNumber<Opt> {
+    return {...infos, title, optional, type: "number"};
+}
+
+//endregion
+
+//region File
+
+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 function file<Opt extends boolean>(title: string, optional: Opt, infos?: OnlyInfos<ScFile<Opt>>): ScFile<Opt> {
+    return {...infos, title, optional, type: "file"};
+}
+
+//endregion
+
+//endregion
+
+/*const MAKE_OPTIONAL = true;
+//
+const UserSchema1 = schema({
+    testOptional: string("testOptional", true),
+    testString: string("testString", MAKE_OPTIONAL),
+    testBool: boolean("testBool", MAKE_OPTIONAL),
+    testNumber: number("testNumber", MAKE_OPTIONAL),
+    testFile: file("testFile", MAKE_OPTIONAL)
+})
+
+type UserDataType1 = SchemaToType<typeof UserSchema1>;
+let ud1: UserDataType1 = {};*/

package/src/jk_streams/index.ts

@@ -0,0 +1,6 @@
+export function teeResponse(r: Response): Promise<[ReadableStream, Response]> {
+    const [b1, b2] = r.body!.tee();
+
+    // The old response body is consumed. So we must rebuild the response.
+    return Promise.resolve([b1, new Response(b2, {status: r.status, headers: r.headers})]);
+}