miqro 6.1.1 → 6.1.3

package/build/esm/src/bin/doc-md.js

@@ -0,0 +1,186 @@
+/*interface SchemaProperties {
+  [key: string]: Schema | string;
+}
+
+type ParserMode = "add_extra" | "no_extra" | "remove_extra"*/
+export async function getMDDoc(args, logger) {
+    const pathList = Object.keys(args.jsonDoc).sort();
+    let outMD = "";
+    const tableIndexItems = [];
+    for (const path of pathList) {
+        const pathData = args.jsonDoc[path];
+        const methods = Object.keys(pathData);
+        for (const method of methods) {
+            if (method) {
+                const apiDataList = pathData[method];
+                for (const apiData of apiDataList) {
+                    tableIndexItems.push({
+                        apiData
+                    });
+                    outMD += `## ${apiData.identifier /*.replaceAll("_", "-")*/}\n\n`;
+                    outMD += `${args.showFilePath && apiData.___filePath ? apiData.___filePath + "\n\n" : ""}`;
+                    if (apiData.name) {
+                        outMD += `${apiData.name}\n\n`;
+                    }
+                    if (apiData.description) {
+                        outMD += `${apiData.description}\n\n`;
+                    }
+                    outMD += `[${method}] ${path}\n\n`;
+                    outMD += `[${path}](${path}) \n\n`;
+                    if (apiData.policy) {
+                        outMD += `### policy\n\n`;
+                        outMD += policyToString(apiData.policy);
+                    }
+                    if (apiData.request) {
+                        const requestOutMD = parserToString(apiData.request);
+                        outMD += requestOutMD !== "" ? `### request\n\n${requestOutMD}` : "";
+                    }
+                    if (apiData.response && typeof apiData.response !== "boolean") {
+                        const responseOutMD = parserToString(apiData.response);
+                        outMD += responseOutMD !== "" ? `### response\n\n${responseOutMD}` : "";
+                    }
+                }
+            }
+        }
+    }
+    const indexTable = getIndexTable(tableIndexItems);
+    return `${indexTable}\n\n${outMD}`;
+}
+function getIndexTable(data) {
+    return `${data.map(api => `[${api.apiData.identifier /*.replaceAll("_", "-")*/}](#${api.apiData.identifier /*.replaceAll("_", "-")*/.toLocaleLowerCase()})${api.apiData.name || api.apiData.description ? `\n\n\t${api.apiData.name ? api.apiData.name + " " : ""}${api.apiData.description ? api.apiData.description : ""}` : ""}`).join("\n\n")}`;
+}
+function policyToString(policy) {
+    let outMD = "| groups | policy |\n";
+    outMD += "|--------|--------|\n";
+    outMD += `| ${(policy.groups instanceof Array ? policy.groups : [policy.groups]).join(",")} | ${policy.groupPolicy} |\n\n`;
+    return outMD;
+}
+export function parserToString(parser) {
+    let outMD = "";
+    if (parser.status) {
+        outMD += `#### status\n\n${parser.status instanceof Array ? parser.status.join(",") : parser.status}\n\n`;
+    }
+    if (parser.params && typeof parser.params !== "boolean") {
+        outMD += `#### path params\n\n`;
+        outMD += parserPartToString(parser.params, parser.paramsMode);
+    }
+    if (parser.headers) {
+        outMD += `#### headers\n\n`;
+        outMD += parserPartToString(parser.headers, parser.headersMode);
+    }
+    if (parser.query && parser.query !== true) {
+        outMD += `#### query\n\n`;
+        outMD += parserPartToString(parser.query, parser.queryMode);
+    }
+    if (parser.body && parser.body !== true) {
+        outMD += `#### body\n\n`;
+        outMD += parserPartToString(parser.body, parser.bodyMode);
+    }
+    return outMD;
+}
+function parserPartToString(arg, mode) {
+    if (arg === false) {
+        return "not allowed";
+    }
+    let outMD = "";
+    let maxTabulation = 1;
+    const parsers = arg instanceof Array ? arg : typeof arg === "string" ? [arg] : [arg];
+    for (const parser of parsers) {
+        const ret = internalParserToString(parser);
+        if (ret.maxTabulation > maxTabulation) {
+            maxTabulation = ret.maxTabulation;
+        }
+        outMD += `| | | | ${getTabulation(ret.maxTabulation * 2)}\n`;
+        outMD += `|--------|-------|-------|${getTabulation(ret.maxTabulation * 2, true)}\n`;
+        outMD += `${ret.out}\n\n`;
+    }
+    return outMD;
+}
+function internalParserToString(parser, tabulation = 1) {
+    let outMD = "";
+    let maxTabulation = tabulation;
+    if (typeof parser === "string") {
+        outMD += `${getTabulation(tabulation)}${parser}|\n`;
+    }
+    else {
+        const attrNames = Object.keys(parser);
+        for (const name of attrNames) {
+            const p = parser[name];
+            const description = typeof p === "string" ? "" : p.description ? p.description : "";
+            if (typeof p === "string") {
+                outMD += `${getTabulation(tabulation)}${name} | ${p}|\n`;
+            }
+            else if (p.type.toLocaleLowerCase() === "object" || p.type.toLocaleLowerCase() === "object?") {
+                const rString = p.required === false || p.type.toLocaleLowerCase() === "object?" ? "?" : "";
+                outMD += `${getTabulation(tabulation)}${name} | object${rString}| ${description}|\n`;
+                const ret = parserBaseObjectTypeToString(p, tabulation + 1);
+                if (maxTabulation < ret.maxTabulation) {
+                    maxTabulation = ret.maxTabulation;
+                }
+                outMD += `${ret.out}`;
+            }
+            else if (p.type.toLocaleLowerCase() === "dict" || p.type.toLocaleLowerCase() === "dict?") {
+                const rString = p.required === false || p.type.toLocaleLowerCase() === "dict?" ? "?" : "";
+                outMD += `${getTabulation(tabulation)}${name} | Dict\\<${p.dictType}\>${rString}| ${description}|\n`;
+                if (p.dictType === "object") {
+                    const ret = parserBaseObjectTypeToString(p, tabulation + 1);
+                    if (maxTabulation < ret.maxTabulation) {
+                        maxTabulation = ret.maxTabulation;
+                    }
+                    outMD += `${ret.out}`;
+                }
+            }
+            else if (p.type.toLocaleLowerCase() === "array" || p.type.toLocaleLowerCase() === "array?") {
+                const rString = p.required === false || p.type.toLocaleLowerCase() === "array?" ? "?" : "";
+                outMD += `${getTabulation(tabulation)}${name} | Array\\<${p.arrayType}\>${rString}| ${description}|\n`;
+                if (p.arrayType.toLocaleLowerCase() === "object") {
+                    const ret = parserBaseObjectTypeToString(p, tabulation + 1);
+                    if (maxTabulation < ret.maxTabulation) {
+                        maxTabulation = ret.maxTabulation;
+                    }
+                    outMD += `${ret.out}`;
+                }
+            }
+            else if (p.type.toLocaleLowerCase() === "regex") {
+                outMD += `${getTabulation(tabulation)}${name} | ${p.regex}| ${description}|\n`;
+            }
+            else if (p.type.toLocaleLowerCase() === "regex?") {
+                outMD += `${getTabulation(tabulation)}${name} | ${p.regex}?| ${description}|\n`;
+            }
+            else if (p.type.toLocaleLowerCase() === "enum") {
+                outMD += `${getTabulation(tabulation)}${name} | ${p.type}| ${description}|\n`;
+                outMD += `${getTabulation(tabulation + 1)}| ${p.enumValues?.join(",")}|\n`;
+                if (maxTabulation < tabulation + 1) {
+                    maxTabulation = tabulation + 1;
+                }
+            }
+            else if (p.type.toLocaleLowerCase() === "enum?") {
+                outMD += `${getTabulation(tabulation)}${name} | ${p.type}?| ${description}|\n`;
+                outMD += `${getTabulation(tabulation + 1)}| ${p.enumValues?.join(",")}|\n`;
+                if (maxTabulation < tabulation + 1) {
+                    maxTabulation = tabulation + 1;
+                }
+            }
+            else {
+                const rString = p.required === false ? "?" : "";
+                outMD += `${getTabulation(tabulation)}${name} | ${p.type}${rString}| ${description}|\n`;
+            }
+        }
+    }
+    return {
+        out: outMD,
+        maxTabulation
+    };
+}
+function parserBaseObjectTypeToString(arg, tabulation) {
+    const options = arg.properties ? arg.properties : {};
+    //const outMD = `${getTabulation(tabulation)}name | type |\n${getTabulation(tabulation)}--------|--------|\n`;
+    return internalParserToString(options, tabulation + 1);
+}
+function getTabulation(n, header = false) {
+    let out = "";
+    for (let i = 0; i < n; i++) {
+        out += header ? "-|" : "| ";
+    }
+    return out;
+}

package/build/esm/src/bin/generate-doc.d.ts

@@ -0,0 +1,6 @@
+import { Logger, Router } from "@miqro/core";
+import { Arguments } from "../common/arguments.js";
+import { InflatedResult } from "../services/app.js";
+import { RouteFileMap } from "../inflate/setup-http.js";
+export declare function generateDocs(args: Arguments, logger: Logger, result: InflatedResult): Promise<void>;
+export declare function getDocOutput(router: Router, fileMap: RouteFileMap, generateDocAll: boolean, generateDocType: "MD" | "JSON" | "HTML"): Promise<string>;

package/build/esm/src/bin/generate-doc.js

@@ -0,0 +1,53 @@
+import { writeFileSync } from "node:fs";
+import { getMDDoc } from "./doc-md.js";
+import { EXIT_CODES } from "../common/constants.js";
+import { inflateMDString2HTML } from "../inflate/md.js";
+export async function generateDocs(args, logger, result) {
+    logger.info("writing [%s]", args.generateDocOut);
+    writeFileSync(args.generateDocOut, await getDocOutput(result.router, result.fileMap, args.generateDocAll, args.generateDocType));
+}
+export async function getDocOutput(router, fileMap, generateDocAll, generateDocType) {
+    /*
+      ** TODO FIX THIS MESS
+      */
+    const fileMapAPIRouteList = Object.keys(fileMap).map(f => fileMap[f]).filter(fMap => fMap.previewMethod === "api").map(fMap => fMap.routes);
+    const jsonDoc = router.getJSONDoc();
+    if (!generateDocAll) {
+        Object.keys(jsonDoc).forEach(path => {
+            const methods = Object.keys(jsonDoc[path]);
+            methods.forEach(method => {
+                const data = jsonDoc[path][method];
+                //console.log("[%s] [%s]", path, method);
+                if (fileMapAPIRouteList.filter(f => {
+                    for (const r of f) {
+                        if (r.method === String(method).toUpperCase() && r.path === path) {
+                            return true;
+                        }
+                    }
+                    return false;
+                }).length === 0) {
+                    //console.log("DELETE [%s] [%s]", path, method);
+                    delete jsonDoc[path][method];
+                }
+                else {
+                    //console.log("KEEP [%s] [%s]", path, method);
+                }
+            });
+        });
+    }
+    switch (generateDocType) {
+        case "JSON":
+            return JSON.stringify(jsonDoc, undefined, 2);
+            break;
+        case "MD":
+            return await getMDDoc({ showFilePath: true, jsonDoc });
+            break;
+        case "HTML":
+            const md = await getMDDoc({ showFilePath: true, jsonDoc });
+            const html = inflateMDString2HTML(md);
+            return html;
+            break;
+        default:
+            process.exit(EXIT_CODES.BAD_ARGUMENTS);
+    }
+}

package/build/esm/src/bin/test.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { Miqro } from "../services/app.js";
+export declare function testMain(app: Miqro): Promise<void>;

package/build/esm/src/bin/test.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+import { request as reqlRequest } from "@miqro/request";
+import { resetGlobals, runTests } from "@miqro/test/dist/runner/common.js";
+import { getServicePath, TEST_SOCKET } from "../common/paths.js";
+import { createNodeRuntime } from "@miqro/jsx-node";
+import { EXIT_CODES } from "../common/constants.js";
+import { setupTests } from "../inflate/setup-test.js";
+export async function testMain(app) {
+    const startMS = Date.now();
+    //resetTests();
+    resetGlobals();
+    //const testLogger = getLogger("test");
+    globalThis.test = {
+        PORT: TEST_SOCKET,
+        request: (request) => reqlRequest({
+            ...request,
+            socketPath: TEST_SOCKET
+        }),
+        logger: app.logger,
+        sleep: async (ms) => new Promise(resolve => setTimeout(resolve, ms)),
+        jsx: {
+            createRuntime: createNodeRuntime,
+            test: (cb, args) => {
+                return async () => {
+                    const runtime = createNodeRuntime(args.runtimeOptions);
+                    const root = runtime.createElement("root");
+                    const container = runtime.createContainer(root, args.containerOptions);
+                    await cb(container, root, runtime);
+                    container.disconnect();
+                };
+            }
+        }
+    };
+    for (const service of app.options.services) {
+        const servicePath = getServicePath(service);
+        await setupTests(app.logger, servicePath);
+    }
+    console.log("");
+    app.logger.log("===starting tests===");
+    console.log("");
+    const ret = await runTests(undefined, app.logger);
+    console.log("");
+    app.logger.log("===tests ended===");
+    if (ret.failed.length > 0) {
+        console.log("");
+        app.logger.error("===failed tests===");
+        console.log("");
+    }
+    const took = Date.now() - startMS;
+    ret.failed.forEach(e => {
+        app.logger.error("\x1b[31m%s\x1b[0m", e.fullName);
+        app.logger.error(e.error);
+    });
+    console.log("");
+    app.logger.log(ret.passed + " tests passed");
+    if (ret.failed.length > 0) {
+        app.logger.error(ret.failed.length + " failed");
+    }
+    else {
+        app.logger.log(ret.failed.length + " failed");
+    }
+    app.logger.log("took " + took + "ms");
+    if (ret.failed.length > 0) {
+        process.exit(EXIT_CODES.TEST_FAILED);
+    }
+    await app.dbManager.closeAll();
+}

package/build/esm/src/bin/types.d.ts

@@ -0,0 +1,3 @@
+import { MinimalLogger } from "@miqro/core";
+import { Arguments } from "../common/arguments.js";
+export declare function installTypings(args: Arguments, logger: MinimalLogger): Promise<void>;

package/build/esm/src/bin/types.js

@@ -0,0 +1,20 @@
+import { initTypes } from "../common/assets.js";
+import { existsSync, writeFileSync } from "node:fs";
+import { TEMPLATES } from "../../editor/common/templates.js";
+import { EXIT_CODES } from "../common/constants.js";
+export async function installTypings(args, logger) {
+    if (args.installTypes) {
+        logger.debug("writing types");
+        // install typing for typescript only if argument --install-types is set
+        await initTypes(logger);
+    }
+    if (args.installTSConfig && !existsSync("tsconfig.json")) {
+        logger.info("writing tsconfig.json");
+        writeFileSync("tsconfig.json", TEMPLATES["TSCONFIGJSON"].template("", ""));
+    }
+    else if (args.installTSConfig) {
+        logger.error("tsconfig.json already exists!");
+        process.exit(EXIT_CODES.ABNORMAL);
+    }
+    process.exit(EXIT_CODES.NORMAL_EXIT);
+}

package/editor/auth.ts

@@ -0,0 +1,51 @@
+import { AuthConfig, ServerRequest } from "../src/types.js";
+import { AdminRequest } from "./common/admin-interface.js";
+
+export const ADMIN_EDITOR_AUTH_KEY = "$$ADMIN_EDITOR_AUTH_KEY$$";
+
+export const ADMIN_EDITOR_AUTH_QUERY = "key";
+export const ADMIN_EDITOR_AUTH_COOKIE = ADMIN_EDITOR_AUTH_KEY;
+
+export default {
+  authService: {
+    verify: async (args) => {
+
+      const adminInterface = (args.req as AdminRequest).editor;
+      const serverInterface = (args.req as any as ServerRequest).server;
+      const KEY = (adminInterface ? adminInterface.getCache() : serverInterface.cache).get<string>(ADMIN_EDITOR_AUTH_KEY);
+
+      const validSesson = {
+        username: "username",
+        account: "account",
+        groups: [],
+        token: args.token
+      };
+
+      const queryToken = args.req.query[ADMIN_EDITOR_AUTH_QUERY];
+      const cookieToken = args.req.cookies[ADMIN_EDITOR_AUTH_COOKIE];
+
+      //console.log("\n\nqueryToken[%s] cookieToken[%s] KEY[%s]\n\n", queryToken, cookieToken, KEY);
+
+      if (queryToken) {
+        if (queryToken === KEY) {
+          args.res.setCookie(ADMIN_EDITOR_AUTH_COOKIE, KEY, {
+            expires: new Date(Date.now() + 1000 * 60 * 60 * 24 * 31 * 12 * 500),
+            httpOnly: true,
+
+            //secure: true,
+            path: "/",
+            //sameSite: "strict"
+          });
+          args.req.searchParams.delete(ADMIN_EDITOR_AUTH_QUERY);
+          const queryString = args.req.searchParams.toString();
+          const redirect = args.req.path + (queryString ? "?" + queryString : "");
+          await args.res.redirect(redirect);
+          return validSesson;
+        }
+      } else if (cookieToken) {
+        return cookieToken === KEY ? validSesson : null;
+      }
+      return null;
+    },
+  }
+} as AuthConfig;

package/editor/common/admin-interface.ts

@@ -0,0 +1,84 @@
+import { RouterHandlerOptions } from "@miqro/core";
+import { CacheInterface, ServerRequest } from "../../src/types.js";
+import { MigrationModule } from "../../src/inflate/setup-db.js";
+
+export interface EditorAdminInterface {
+  getCache: () => CacheInterface;
+  //inflateJSX: (path: string, minify?: boolean) => Promise<string>;
+  getMigrations(): MigrationModule[];
+  stop: () => Promise<void>;
+  reload: () => Promise<null | {
+    filePath: string;
+    error: Error;
+  }[]>;
+  restart: () => Promise<null | {
+    filePath: string;
+    error: Error;
+  }[]>;
+  getHotReloadHTML(): string;
+  getInflateErrors(): null | {
+    filePath: string;
+    error: Error;
+  }[];
+  getServices(): string[];
+  getRouteFileMap(): {
+    [filePath: string]: {
+      routes: {
+        path?: string;
+        method?: string | null;
+        options?: RouterHandlerOptions;
+        inflatePath?: string;
+      }[];
+      previewMethod: "api" | "html" | null;
+    }
+  };
+}
+
+export interface AdminRequest extends ServerRequest {
+  editor?: EditorAdminInterface;
+}
+
+/*let currentAdminInterface: EditorAdminInterface | null = null;
+function createFakeAdminInterface(server: any): EditorAdminInterface {
+  return {
+    getCache: () => {
+      return server.cache;
+    },
+    stop: async () => {
+
+    },
+    restart: async () => {
+      return null;
+    },
+    reload: async () => {
+      return null;
+    },
+    getHotReloadHTML: () => {
+      return "";
+    },
+    getMigrations: () => {
+      return [];
+    },
+    getServices: () => {
+      return ["."];
+    },
+    getRouteFileMap: () => {
+      return {};
+    },
+    getInflateErrors: () => {
+      return [];
+    },
+    inflateJSX: async function inflateJSX(path, minify: boolean = true) {
+      return "";
+    }
+  }
+}
+
+export function getEditorAdmin(server): EditorAdminInterface {
+  return currentAdminInterface ? currentAdminInterface : createFakeAdminInterface(server);
+}
+
+export function setEditorAdmin(admin: EditorAdminInterface): void {
+  currentAdminInterface = admin;
+}*/
+

package/editor/common/constants.server.ts

@@ -0,0 +1,5 @@
+import { resolve } from "node:path";
+import { cwd } from "node:process";
+
+export const PORT = process.env["PORT"] ? process.env["PORT"] : "8080";
+export const BASE_PATH = resolve(cwd());

package/editor/common/constants.ts

@@ -0,0 +1,21 @@
+export const BASEEDITOR_PATH = "/admin/editor";
+export const LOG_SOCKET_PATH = "/admin/socket";
+export const LOG_WRITE_EVENT = "LogWrite";
+
+export const SUPPORTED_LANGUAGES = [
+  "text",
+  "json",
+  "javascript",
+  "typescript",
+  "dockerfile",
+  "yaml",
+  "xml",
+  "html",
+  "css",
+  "scss",
+  "markdown",
+  "c",
+  "cpp",
+  "bash",
+  "python"
+];

package/editor/common/editor-index.tsx

@@ -0,0 +1,17 @@
+import { scanDir } from "../http/admin/editor/api/fs/scan.api.js";
+import { parseInflateErrors } from "../http/admin/editor/api/server/restart.api.js";
+import { AdminRequest } from "./admin-interface.js";
+import { HTMLEncode } from "./html-encode.js";
+
+export function EditorIndex(editorCSS: string, editorJS: string, enableHotReload: boolean) {
+  return async function editorIndex(req: AdminRequest, res) {
+    const admin = req.editor;
+
+    const errors = parseInflateErrors(admin ? admin.getInflateErrors() : []);
+    const files = scanDir(req);
+    const migrations = admin ? admin.getMigrations().map(m => m.name) : [];
+    const services = admin ? admin.getServices() : ["."];
+    const hotReload = enableHotReload ? (admin ? admin.getHotReloadHTML() : "") : "";
+    res.html(`<!DOCTYPE html><html><body><style>${editorCSS}</style><script type="module">${editorJS}</script><editor-component class="main-container" reloadstring="${req.uuid}" migrations="${HTMLEncode(JSON.stringify(migrations))}" services="${HTMLEncode(JSON.stringify(services))}" errors="${HTMLEncode(JSON.stringify(errors))}" files="${HTMLEncode(JSON.stringify(files))}"><noscript>Enable JavaScript</noscript></editor-component>${hotReload}</body></html>`)
+  }
+}

package/editor/common/html-encode.ts

@@ -0,0 +1,14 @@
+export function HTMLEncode(str: string): string {
+  let i = str.length;
+  const aRet: string[] = [];
+
+  while (i--) {
+    const iC = str[i].charCodeAt(0);
+    if (iC < 65 || iC > 127 || (iC > 90 && iC < 97)) {
+      aRet[i] = '&#' + iC + ';';
+    } else {
+      aRet[i] = str[i];
+    }
+  }
+  return aRet.join('');
+}

package/editor/common/log-socket.tsx

@@ -0,0 +1,85 @@
+interface LogLine { out: string; identifier: string; level: "error" | "warn" | "debug" | "trace" | "info" }
+
+export interface LogSocket {
+  lines: LogLine[];
+  clearLog: () => void;
+  getMaxlogsize: () => number | "unlimited";
+  setMaxLogSize: (val: number | "unlimited") => void;
+}
+
+export function useLogSocket(options: { disableLog?: boolean; }): LogSocket {
+
+  const [_, setmaxLogSize, getMaxlogsize] = jsx.useState<number | "unlimited">(1000000);
+
+  const [__, setlines, getLines] = jsx.useState<LogLine[]>([]);
+  const refresh = jsx.useRefresh();
+
+  jsx.useEffect(() => {
+
+    let timeout;
+
+    function setupSocket() {
+      try {
+        if (options.disableLog) {
+          return;
+        }
+        console.log("setting up log socket");
+        const socket = new WebSocket("/admin/socket");
+        socket.addEventListener("error", (err) => {
+          console.error(err);
+          clearTimeout(timeout);
+          timeout = setTimeout(() => {
+            setupSocket();
+          }, 1000);
+        });
+        socket.addEventListener("open", () => {
+          console.log("log socket open");
+          clearTimeout(timeout);
+          socket.addEventListener("message", (msg) => {
+            const lines = getLines();
+            const data = JSON.parse(msg.data);
+            //console.log(data.out);
+            const maxLogSize = getMaxlogsize();
+            if (maxLogSize !== "unlimited" && lines.length >= maxLogSize) {
+              lines.splice(0, (lines.length - maxLogSize) + 1);
+            }
+            lines.push(data);
+            setlines(lines);
+            refresh();
+          });
+        });
+        socket.addEventListener("close", () => {
+          console.log("log socket close");
+          clearTimeout(timeout);
+          timeout = setTimeout(() => {
+            setupSocket();
+          }, 1000);
+        });
+      } catch (e) {
+        console.error(e);
+        clearTimeout(timeout);
+        timeout = setTimeout(() => {
+          setupSocket();
+        }, 1000);
+      }
+    }
+
+    setupSocket();
+  }, []);
+
+  return {
+    lines: getLines(),
+    clearLog: () => {
+      setlines([]);
+    },
+    getMaxlogsize,
+    setMaxLogSize: (newValue: number | "unlimited") => {
+      if (newValue === "unlimited") {
+        setmaxLogSize(newValue);
+      } else {
+        setmaxLogSize(newValue);
+      }
+
+    }
+  }
+}