@forgerapi/codegen 0.0.1

package/dist/index.js

@@ -0,0 +1,376 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUpdateDto = exports.generateResponseDto = exports.generatePrismaService = exports.generatePrismaSchema = exports.generatePrismaModule = exports.generateModule = exports.generateModelImpl = exports.generateForgerModules = exports.generateEnum = exports.generateCreateDto = exports.generateController = exports.generateAbstractService = void 0;
+exports.generate = generate;
+exports.runForger = runForger;
+exports.watchForger = watchForger;
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const parser_1 = require("@forgerapi/parser");
+const codemod_1 = require("./codemod");
+const controller_1 = require("./generators/controller");
+Object.defineProperty(exports, "generateController", { enumerable: true, get: function () { return controller_1.generateController; } });
+const dto_1 = require("./generators/dto");
+Object.defineProperty(exports, "generateCreateDto", { enumerable: true, get: function () { return dto_1.generateCreateDto; } });
+Object.defineProperty(exports, "generateResponseDto", { enumerable: true, get: function () { return dto_1.generateResponseDto; } });
+Object.defineProperty(exports, "generateUpdateDto", { enumerable: true, get: function () { return dto_1.generateUpdateDto; } });
+const enum_1 = require("./generators/enum");
+Object.defineProperty(exports, "generateEnum", { enumerable: true, get: function () { return enum_1.generateEnum; } });
+const module_1 = require("./generators/module");
+Object.defineProperty(exports, "generateModule", { enumerable: true, get: function () { return module_1.generateModule; } });
+const prisma_1 = require("./generators/prisma");
+Object.defineProperty(exports, "generatePrismaSchema", { enumerable: true, get: function () { return prisma_1.generatePrismaSchema; } });
+const prisma_module_1 = require("./generators/prisma-module");
+Object.defineProperty(exports, "generatePrismaModule", { enumerable: true, get: function () { return prisma_module_1.generatePrismaModule; } });
+const prisma_service_1 = require("./generators/prisma-service");
+Object.defineProperty(exports, "generatePrismaService", { enumerable: true, get: function () { return prisma_service_1.generatePrismaService; } });
+const service_1 = require("./generators/service");
+Object.defineProperty(exports, "generateAbstractService", { enumerable: true, get: function () { return service_1.generateAbstractService; } });
+Object.defineProperty(exports, "generateModelImpl", { enumerable: true, get: function () { return service_1.generateModelImpl; } });
+const utils_1 = require("./utils");
+const action_1 = require("./generators/action");
+const guard_1 = require("./generators/guard");
+const forger_module_1 = require("./generators/forger-module");
+const forger_modules_1 = require("./generators/forger-modules");
+Object.defineProperty(exports, "generateForgerModules", { enumerable: true, get: function () { return forger_modules_1.generateForgerModules; } });
+const schema_cache_1 = require("./schema-cache");
+async function generate(schema, config) {
+    const files = [];
+    const swaggerConfig = { enabled: config.swagger ?? true };
+    files.push(...(await generatePrisma(schema, config)));
+    files.push(...(await generatePrismaServiceFile(config)));
+    files.push(...(await generateModels(schema, config, swaggerConfig)));
+    files.push(...(await generateActions(schema, config)));
+    files.push(...(await generateModules(schema, config, swaggerConfig)));
+    files.push(...(await generateGuards(schema, config)));
+    files.push(...(await generateEnums(schema, config)));
+    files.push(...(await generateForgerModulesFile(schema, config)));
+    files.push(...(await deleteOrphans(schema, config)));
+    return files;
+}
+async function ensureDir(dir) {
+    if (!(0, node_fs_1.existsSync)(dir)) {
+        await (0, promises_1.mkdir)(dir, { recursive: true });
+    }
+}
+async function generatePrisma(schema, config) {
+    const prismaDir = (0, node_path_1.dirname)(config.prismaSchema);
+    await ensureDir(prismaDir);
+    const content = (0, prisma_1.generatePrismaSchema)(schema);
+    await (0, promises_1.writeFile)(config.prismaSchema, content, "utf-8");
+    return [config.prismaSchema];
+}
+async function generateModels(schema, config, swagger) {
+    const files = [];
+    for (const model of schema.models) {
+        const kebab = (0, utils_1.toKebab)(model.name);
+        const modelDir = (0, node_path_1.resolve)(config.outDir, kebab);
+        const implDir = (0, node_path_1.resolve)(modelDir, "impl");
+        await ensureDir((0, node_path_1.resolve)(modelDir, "dto"));
+        await ensureDir(implDir);
+        const dtoPaths = [
+            (0, node_path_1.resolve)(modelDir, `dto/create-${kebab}.dto.ts`),
+            (0, node_path_1.resolve)(modelDir, `dto/update-${kebab}.dto.ts`),
+            (0, node_path_1.resolve)(modelDir, `dto/${kebab}-response.dto.ts`),
+        ];
+        const dtoContents = [
+            (0, dto_1.generateCreateDto)(model, schema, swagger, {
+                enumBase: "../../common/enums",
+            }),
+            (0, dto_1.generateUpdateDto)(model),
+            (0, dto_1.generateResponseDto)(model),
+        ];
+        for (let i = 0; i < dtoPaths.length; i++) {
+            await (0, promises_1.writeFile)(dtoPaths[i], dtoContents[i]);
+        }
+        files.push(...dtoPaths);
+        const servicePath = (0, node_path_1.resolve)(modelDir, `${kebab}.service.ts`);
+        await (0, promises_1.writeFile)(servicePath, (0, service_1.generateAbstractService)(model));
+        files.push(servicePath);
+        const controllerPath = (0, node_path_1.resolve)(modelDir, `${kebab}.controller.ts`);
+        await (0, promises_1.writeFile)(controllerPath, (0, controller_1.generateController)(model, swagger));
+        files.push(controllerPath);
+        const modulePath = (0, node_path_1.resolve)(modelDir, `${kebab}.module.ts`);
+        await (0, promises_1.writeFile)(modulePath, (0, module_1.generateModule)(model, {
+            implRelative: `./impl/${kebab}.impl`,
+        }));
+        files.push(modulePath);
+        const implPath = (0, node_path_1.resolve)(implDir, `${kebab}.impl.ts`);
+        if (!(0, node_fs_1.existsSync)(implPath)) {
+            await (0, promises_1.writeFile)(implPath, (0, service_1.generateModelImpl)(model, {
+                serviceRelative: `../${kebab}.service`,
+                createDtoRelative: `../dto/create-${kebab}.dto`,
+                updateDtoRelative: `../dto/update-${kebab}.dto`,
+                prismaRelative: `../../common/prisma/prisma.service`,
+            }));
+            files.push(implPath);
+        }
+    }
+    return files;
+}
+async function generateActions(schema, config) {
+    if (schema.actions.length === 0)
+        return [];
+    const files = [];
+    for (const action of schema.actions) {
+        const kebab = (0, utils_1.toKebab)(action.name);
+        const actionDir = (0, node_path_1.resolve)(config.outDir, kebab);
+        const implDir = (0, node_path_1.resolve)(actionDir, "impl");
+        await ensureDir((0, node_path_1.resolve)(actionDir, "dto"));
+        await ensureDir(implDir);
+        const dtoPath = (0, node_path_1.resolve)(actionDir, `${kebab}.action-dto.ts`);
+        await (0, promises_1.writeFile)(dtoPath, (0, action_1.generateActionDto)(action));
+        files.push(dtoPath);
+        const servicePath = (0, node_path_1.resolve)(actionDir, `${kebab}.action-service.ts`);
+        await (0, promises_1.writeFile)(servicePath, (0, action_1.generateActionService)(action));
+        files.push(servicePath);
+        const controllerPath = (0, node_path_1.resolve)(actionDir, `${kebab}.action-controller.ts`);
+        await (0, promises_1.writeFile)(controllerPath, (0, action_1.generateActionController)(action));
+        files.push(controllerPath);
+        const modulePath = (0, node_path_1.resolve)(actionDir, `${kebab}.action-module.ts`);
+        await (0, promises_1.writeFile)(modulePath, (0, action_1.generateActionModule)(action, {
+            implRelative: `./impl/${kebab}.action-impl`,
+        }));
+        files.push(modulePath);
+        const implPath = (0, node_path_1.resolve)(implDir, `${kebab}.action-impl.ts`);
+        if (!(0, node_fs_1.existsSync)(implPath)) {
+            await (0, promises_1.writeFile)(implPath, (0, action_1.generateActionImpl)(action, {
+                serviceRelative: `../${kebab}.action-service`,
+                dtoRelative: `../${kebab}.action-dto`,
+            }));
+            files.push(implPath);
+        }
+        if (action.emits) {
+            for (const eventName of action.emits) {
+                const eventPath = (0, node_path_1.resolve)(actionDir, `${kebab}.action-event.ts`);
+                if (!(0, node_fs_1.existsSync)(eventPath)) {
+                    await (0, promises_1.writeFile)(eventPath, (0, action_1.generateActionEvent)(action.name, eventName));
+                    files.push(eventPath);
+                }
+            }
+        }
+    }
+    return files;
+}
+async function generateModules(schema, config, _swagger) {
+    if (schema.modules.length === 0)
+        return [];
+    const files = [];
+    const guardMap = new Map(schema.guards.map((g) => [g.name, g]));
+    for (const mod of schema.modules) {
+        const modKebab = (0, utils_1.toKebab)(mod.name);
+        const moduleDir = (0, node_path_1.resolve)(config.outDir, modKebab);
+        const actionsDir = (0, node_path_1.resolve)(moduleDir, "actions");
+        const eventsDir = (0, node_path_1.resolve)(moduleDir, "events");
+        const implDir = (0, node_path_1.resolve)(moduleDir, "impl");
+        await ensureDir(moduleDir);
+        await ensureDir(eventsDir);
+        await ensureDir(implDir);
+        const modGuards = mod.guards
+            .map((g) => guardMap.get(g))
+            .filter((g) => g !== undefined);
+        for (const action of mod.actions) {
+            const kebab = (0, utils_1.toKebab)(action.name);
+            const actionDir = (0, node_path_1.resolve)(actionsDir, kebab);
+            await ensureDir((0, node_path_1.resolve)(actionDir, "dto"));
+            const dtoPath = (0, node_path_1.resolve)(actionDir, `${kebab}.action-dto.ts`);
+            await (0, promises_1.writeFile)(dtoPath, (0, action_1.generateActionDto)(action));
+            files.push(dtoPath);
+            const servicePath = (0, node_path_1.resolve)(actionDir, `${kebab}.action-service.ts`);
+            await (0, promises_1.writeFile)(servicePath, (0, action_1.generateActionService)(action));
+            files.push(servicePath);
+            const controllerPath = (0, node_path_1.resolve)(actionDir, `${kebab}.action-controller.ts`);
+            await (0, promises_1.writeFile)(controllerPath, (0, action_1.generateActionController)(action, {
+                routePrefix: mod.route.startsWith("/")
+                    ? mod.route.slice(1)
+                    : mod.route,
+                guards: modGuards,
+            }));
+            files.push(controllerPath);
+            const implFilePath = (0, node_path_1.resolve)(implDir, `${kebab}.action-impl.ts`);
+            if (!(0, node_fs_1.existsSync)(implFilePath)) {
+                await (0, promises_1.writeFile)(implFilePath, (0, action_1.generateActionImpl)(action, {
+                    serviceRelative: `../actions/${kebab}/${kebab}.action-service`,
+                    dtoRelative: `../actions/${kebab}/${kebab}.action-dto`,
+                }));
+                files.push(implFilePath);
+            }
+            if (action.emits) {
+                for (const eventName of action.emits) {
+                    const eventPath = (0, node_path_1.resolve)(eventsDir, `${kebab}.action-event.ts`);
+                    if (!(0, node_fs_1.existsSync)(eventPath)) {
+                        await (0, promises_1.writeFile)(eventPath, (0, action_1.generateActionEvent)(action.name, eventName));
+                        files.push(eventPath);
+                    }
+                }
+            }
+        }
+        const modulePath = (0, node_path_1.resolve)(moduleDir, `${modKebab}.module.ts`);
+        await (0, promises_1.writeFile)(modulePath, (0, forger_module_1.generateForgerModule)(mod, {
+            modelRelativeBase: "..",
+            actionBase: "./actions",
+            implBase: "./impl",
+        }));
+        files.push(modulePath);
+    }
+    return files;
+}
+async function generateGuards(schema, config) {
+    const guardsWithStubs = schema.guards.filter((g) => !g.import);
+    if (guardsWithStubs.length === 0)
+        return [];
+    const files = [];
+    const guardDir = (0, node_path_1.resolve)(config.outDir, "common", "guards");
+    await ensureDir(guardDir);
+    for (const guard of guardsWithStubs) {
+        const p = (0, node_path_1.resolve)(guardDir, `${(0, utils_1.toKebab)(guard.name)}.guard.ts`);
+        await (0, promises_1.writeFile)(p, (0, guard_1.generateGuardStub)(guard));
+        files.push(p);
+    }
+    return files;
+}
+async function generateForgerModulesFile(schema, config) {
+    if (schema.models.length === 0 &&
+        schema.actions.length === 0 &&
+        schema.modules.length === 0)
+        return [];
+    const p = (0, node_path_1.resolve)(config.outDir, "forger-modules.module.ts");
+    await (0, promises_1.writeFile)(p, (0, forger_modules_1.generateForgerModules)(schema.models, schema.actions, schema.modules));
+    return [p];
+}
+async function generateEnums(schema, config) {
+    if (schema.enums.length === 0)
+        return [];
+    const commonDir = (0, node_path_1.resolve)(config.outDir, "common", "enums");
+    await ensureDir(commonDir);
+    const files = [];
+    for (const enm of schema.enums) {
+        const p = (0, node_path_1.resolve)(commonDir, `${(0, utils_1.toKebab)(enm.name)}.enum.ts`);
+        await (0, promises_1.writeFile)(p, (0, enum_1.generateEnum)(enm));
+        files.push(p);
+    }
+    return files;
+}
+async function generatePrismaServiceFile(config) {
+    const prismaDir = (0, node_path_1.resolve)(config.outDir, "common", "prisma");
+    await ensureDir(prismaDir);
+    const p = (0, node_path_1.resolve)(prismaDir, "prisma.service.ts");
+    await (0, promises_1.writeFile)(p, (0, prisma_service_1.generatePrismaService)());
+    const modulePath = (0, node_path_1.resolve)(prismaDir, "prisma.module.ts");
+    await (0, promises_1.writeFile)(modulePath, (0, prisma_module_1.generatePrismaModule)());
+    return [p, modulePath];
+}
+async function deleteOrphans(schema, config) {
+    if (!config.deleteOrphans)
+        return [];
+    if (!(0, node_fs_1.existsSync)(config.outDir))
+        return [];
+    const files = [];
+    const validDirs = new Set(schema.models.map((m) => (0, utils_1.toKebab)(m.name)));
+    validDirs.add("common");
+    for (const action of schema.actions) {
+        validDirs.add((0, utils_1.toKebab)(action.name));
+    }
+    for (const mod of schema.modules) {
+        validDirs.add((0, utils_1.toKebab)(mod.name));
+    }
+    const entries = (0, node_fs_1.readdirSync)(config.outDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.isDirectory() && !validDirs.has(entry.name)) {
+            const dir = (0, node_path_1.resolve)(config.outDir, entry.name);
+            await (0, promises_1.rm)(dir, { recursive: true, force: true });
+            files.push(dir);
+        }
+    }
+    return files;
+}
+async function runForger(config) {
+    const root = process.cwd();
+    const forgerFile = (0, node_path_1.resolve)(root, "schema.forger");
+    if (!(0, node_fs_1.existsSync)(forgerFile)) {
+        throw new Error("schema.forger file not found in project root");
+    }
+    const source = (0, node_fs_1.readFileSync)(forgerFile, "utf-8");
+    const schema = (0, parser_1.parse)(source);
+    (0, parser_1.analyze)(schema);
+    const cached = (0, schema_cache_1.readCache)(root);
+    const codemodLogs = [];
+    if (cached) {
+        const diff = (0, schema_cache_1.diffSchemas)(cached, schema);
+        if (diff.renames.length > 0) {
+            const logs = (0, codemod_1.applyCodemod)(config.outDir, diff.renames);
+            codemodLogs.push(...logs);
+        }
+    }
+    (0, schema_cache_1.writeCache)(root, schema);
+    const files = await generate(schema, config);
+    const hasModules = schema.models.length > 0 ||
+        schema.actions.length > 0 ||
+        schema.modules.length > 0;
+    const registerLog = (0, codemod_1.registerForgerModules)(config.outDir, hasModules);
+    if (registerLog)
+        codemodLogs.push(registerLog);
+    if (codemodLogs.length > 0) {
+        console.log("\x1b[33m[codemod]\x1b[0m");
+        for (const log of codemodLogs) {
+            console.log(log);
+        }
+    }
+    return files;
+}
+function watchForger(config) {
+    const forgerFile = (0, node_path_1.resolve)(process.cwd(), "schema.forger");
+    let running = false;
+    async function regenerate() {
+        if (running)
+            return;
+        running = true;
+        try {
+            const source = (0, node_fs_1.readFileSync)(forgerFile, "utf-8");
+            const schema = (0, parser_1.parse)(source);
+            (0, parser_1.analyze)(schema);
+            const root = process.cwd();
+            const cached = (0, schema_cache_1.readCache)(root);
+            const codemodLogs = [];
+            if (cached) {
+                const diff = (0, schema_cache_1.diffSchemas)(cached, schema);
+                if (diff.renames.length > 0) {
+                    const logs = (0, codemod_1.applyCodemod)(config.outDir, diff.renames);
+                    codemodLogs.push(...logs);
+                }
+            }
+            (0, schema_cache_1.writeCache)(root, schema);
+            const files = await generate(schema, config);
+            const hasModules = schema.models.length > 0 ||
+                schema.actions.length > 0 ||
+                schema.modules.length > 0;
+            const registerLog = (0, codemod_1.registerForgerModules)(config.outDir, hasModules);
+            if (registerLog)
+                codemodLogs.push(registerLog);
+            const t = new Date().toLocaleTimeString();
+            console.log(`\x1b[36m[${t}]\x1b[0m \x1b[32m✓\x1b[0m ${files.length} files`);
+            if (codemodLogs.length > 0) {
+                console.log("\x1b[33m[codemod]\x1b[0m");
+                for (const log of codemodLogs) {
+                    console.log(log);
+                }
+            }
+        }
+        catch (err) {
+            const t = new Date().toLocaleTimeString();
+            console.error(`\x1b[36m[${t}]\x1b[0m \x1b[31m✗\x1b[0m ${err.message}`);
+        }
+        finally {
+            running = false;
+        }
+    }
+    regenerate();
+    console.log("\x1b[36m[\x1b[35mwatch\x1b[36m]\x1b[0m watching schema.forger");
+    let timer = null;
+    (0, node_fs_1.watch)(forgerFile, () => {
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(regenerate, 300);
+    });
+}

package/dist/schema-cache.d.ts

@@ -0,0 +1,25 @@
+import type { ForgerAction, ForgerEnum, ForgerEvent, ForgerModel, ForgerSchema } from "@forgerapi/ast";
+interface CachedSchema {
+    enums: ForgerEnum[];
+    models: ForgerModel[];
+    actions: ForgerAction[];
+    events: ForgerEvent[];
+}
+export interface SchemaDiff {
+    addedModels: ForgerModel[];
+    removedModels: ForgerModel[];
+    addedActions: ForgerAction[];
+    removedActions: ForgerAction[];
+    addedEvents: ForgerEvent[];
+    removedEvents: ForgerEvent[];
+    renames: RenameInfo[];
+}
+export interface RenameInfo {
+    type: "model" | "action" | "event";
+    oldName: string;
+    newName: string;
+}
+export declare function readCache(root: string): CachedSchema | null;
+export declare function writeCache(root: string, schema: ForgerSchema): void;
+export declare function diffSchemas(old: CachedSchema, current: ForgerSchema): SchemaDiff;
+export {};

package/dist/schema-cache.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCache = readCache;
+exports.writeCache = writeCache;
+exports.diffSchemas = diffSchemas;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const CACHE_FILE = ".schema-cache.json";
+function readCache(root) {
+    const path = (0, node_path_1.resolve)(root, CACHE_FILE);
+    if (!(0, node_fs_1.existsSync)(path))
+        return null;
+    try {
+        return JSON.parse((0, node_fs_1.readFileSync)(path, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function writeCache(root, schema) {
+    const path = (0, node_path_1.resolve)(root, CACHE_FILE);
+    (0, node_fs_1.writeFileSync)(path, JSON.stringify(schema, null, 2), "utf-8");
+}
+function diffSchemas(old, current) {
+    const oldModels = new Map(old.models.map((m) => [m.name, m]));
+    const currentModels = new Map(current.models.map((m) => [m.name, m]));
+    const oldActions = new Map(old.actions.map((a) => [a.name, a]));
+    const currentActions = new Map(current.actions.map((a) => [a.name, a]));
+    const oldEvents = new Map(old.events.map((e) => [e.name, e]));
+    const currentEvents = new Map(current.events.map((e) => [e.name, e]));
+    const addedModels = [];
+    const removedModels = [];
+    const addedActions = [];
+    const removedActions = [];
+    const addedEvents = [];
+    const removedEvents = [];
+    const renames = [];
+    for (const [name, m] of oldModels) {
+        if (!currentModels.has(name))
+            removedModels.push(m);
+    }
+    for (const [name, a] of oldActions) {
+        if (!currentActions.has(name))
+            removedActions.push(a);
+    }
+    for (const [name, e] of oldEvents) {
+        if (!currentEvents.has(name))
+            removedEvents.push(e);
+    }
+    for (const [name, m] of currentModels) {
+        if (!oldModels.has(name))
+            addedModels.push(m);
+    }
+    for (const [name, a] of currentActions) {
+        if (!oldActions.has(name))
+            addedActions.push(a);
+    }
+    for (const [name, e] of currentEvents) {
+        if (!oldEvents.has(name))
+            addedEvents.push(e);
+    }
+    if (removedModels.length === 1 && addedModels.length === 1) {
+        const removed = removedModels[0];
+        const added = addedModels[0];
+        const ratio = Math.min(removed.fields.length, added.fields.length) /
+            Math.max(removed.fields.length, added.fields.length);
+        if (ratio >= 0.5) {
+            renames.push({
+                type: "model",
+                oldName: removed.name,
+                newName: added.name,
+            });
+        }
+    }
+    if (removedActions.length === 1 && addedActions.length === 1) {
+        renames.push({
+            type: "action",
+            oldName: removedActions[0].name,
+            newName: addedActions[0].name,
+        });
+    }
+    if (removedEvents.length === 1 && addedEvents.length === 1) {
+        renames.push({
+            type: "event",
+            oldName: removedEvents[0].name,
+            newName: addedEvents[0].name,
+        });
+    }
+    return {
+        addedModels,
+        removedModels,
+        addedActions,
+        removedActions,
+        addedEvents,
+        removedEvents,
+        renames,
+    };
+}

package/dist/utils.d.ts

@@ -0,0 +1 @@
+export declare function toKebab(name: string): string;

package/dist/utils.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toKebab = toKebab;
+function toKebab(name) {
+    return name.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@forgerapi/codegen",
+  "version": "0.0.1",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/linecodesxx/forgerapi.git",
+    "directory": "packages/codegen"
+  },
+  "scripts": {
+    "build": "tsc"
+  },
+  "dependencies": {
+    "@forgerapi/ast": "^0.0.1",
+    "@forgerapi/parser": "^0.0.1",
+    "ts-morph": "^28.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26.0.1"
+  }
+}