adminforth 1.0.17 → 1.0.24

package/dist/modules/codeInjector.js

@@ -0,0 +1,337 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import fs from 'fs';
+import fsExtra from 'fs-extra';
+import filewatcher from 'filewatcher';
+import { exec, spawn } from 'child_process';
+import { promisify } from 'util';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import crypto from 'crypto';
+import os from 'os';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.join(path.dirname(__filename), '..');
+let TMP_DIR;
+try {
+    TMP_DIR = os.tmpdir();
+}
+catch (e) {
+    TMP_DIR = '/tmp';
+}
+const execAsync = promisify(exec);
+function hashify(obj) {
+    return crypto.createHash('sha256').update(JSON.stringify(obj)).digest('hex');
+}
+class CodeInjector {
+    constructor(adminforth) {
+        this.adminforth = adminforth;
+    }
+    // async runShell({command, verbose = false}) {
+    //   console.log(`⚙️ Running shell ${command}...`);
+    //   console.time(`${command} done in`);
+    //   const { stdout: out, stderr: err } = await execAsync(command);
+    //   console.timeEnd(`${command} done in`);
+    //   console.log(`Command ${command} output:`, out, err);
+    // }
+    runNpmShell(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ command, verbose = false, cwd }) {
+            const nodeBinary = process.execPath; // Path to the Node.js binary running this script
+            const npmPath = path.join(path.dirname(nodeBinary), 'npm'); // Path to the npm executable
+            const env = Object.assign({ VUE_APP_ADMINFORTH_PUBLIC_PATH: this.adminforth.config.baseUrl, FORCE_COLOR: '1' }, process.env);
+            console.log(`⚙️ Running npm ${command}...`);
+            console.time(`npm ${command} done in`);
+            const { stdout: out, stderr: err } = yield execAsync(`${nodeBinary} ${npmPath} ${command}`, {
+                cwd,
+                env,
+            });
+            console.timeEnd(`npm ${command} done in`);
+            if (verbose) {
+                console.log(`npm ${command} output:`, out);
+            }
+            if (err) {
+                console.error(`npm ${command} errors/warnings:`, err);
+            }
+        });
+    }
+    rmTmpDir() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // remove spa_tmp folder if it is exists
+            const spaTmpPath = CodeInjector.SPA_TMP_PATH;
+            try {
+                yield fs.promises.rm(spaTmpPath, { recursive: true });
+            }
+            catch (e) {
+                // ignore
+            }
+        });
+    }
+    prepareSources(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ filesUpdated, verbose = false }) {
+            var _b, _c, _d;
+            const spaTmpPath = CodeInjector.SPA_TMP_PATH;
+            // check SPA_TMP_PATH exists and create if not
+            try {
+                yield fs.promises.access(spaTmpPath, fs.constants.F_OK);
+            }
+            catch (e) {
+                yield fs.promises.mkdir(spaTmpPath, { recursive: true });
+            }
+            const icons = [];
+            let routes = '';
+            const collectAssetsFromMenu = (menu) => {
+                menu.forEach((item) => {
+                    if (item.icon) {
+                        icons.push(item.icon);
+                    }
+                    if (item.component) {
+                        routes += `{
+            path: '${item.path}',
+            name: '${item.path}',
+            component: import('${item.component}'),
+          },\n`;
+                    }
+                    if (item.children) {
+                        collectAssetsFromMenu(item.children);
+                    }
+                });
+            };
+            collectAssetsFromMenu(this.adminforth.config.menu);
+            // create spa_tmp folder, or ignore if it exists
+            try {
+                yield fs.promises.mkdir(spaTmpPath);
+            }
+            catch (e) {
+                // ignore
+            }
+            if (filesUpdated) {
+                // copy only updated files
+                yield Promise.all(filesUpdated.map((file) => __awaiter(this, void 0, void 0, function* () {
+                    const src = path.join(__dirname, 'spa', file);
+                    const dest = path.join(spaTmpPath, file);
+                    yield fsExtra.copy(src, dest);
+                })));
+            }
+            else {
+                yield fsExtra.copy(path.join(__dirname, 'spa'), spaTmpPath, {
+                    filter: (src) => {
+                        return !src.includes('/adminforth/spa/node_modules') && !src.includes('/adminforth/spa/dist');
+                    },
+                });
+                // copy whole custom directory
+                if ((_b = this.adminforth.config.customization) === null || _b === void 0 ? void 0 : _b.customComponentsDir) {
+                    yield fsExtra.copy(this.adminforth.config.customization.customComponentsDir, path.join(CodeInjector.SPA_TMP_PATH, 'src', 'custom'), {
+                        recursive: true,
+                    });
+                }
+            }
+            //collect all 'icon' fields from resources bulkActions
+            this.adminforth.config.resources.forEach((resource) => {
+                var _a;
+                if ((_a = resource.options) === null || _a === void 0 ? void 0 : _a.bulkActions) {
+                    resource.options.bulkActions.forEach((action) => {
+                        if (action.icon) {
+                            icons.push(action.icon);
+                        }
+                    });
+                }
+            });
+            const uniqueIcons = Array.from(new Set(icons));
+            // icons are collectionName:iconName. Get list of all unique collection names:
+            const collections = new Set(icons.map((icon) => icon.split(':')[0]));
+            // package names @iconify-prerendered/vue-<collection name>
+            const packageNames = Array.from(collections).map((collection) => `@iconify-prerendered/vue-${collection}`);
+            // for each icon generate import statement
+            const iconImports = uniqueIcons.map((icon) => {
+                const [collection, iconName] = icon.split(':');
+                const PascalIconName = 'Icon' + iconName.split('-').map((part, index) => {
+                    return part[0].toUpperCase() + part.slice(1);
+                }).join('');
+                return `import { ${PascalIconName} } from '@iconify-prerendered/vue-${collection}';`;
+            }).join('\n');
+            // Generate Vue.component statements for each icon
+            const iconComponents = uniqueIcons.map((icon) => {
+                const [collection, iconName] = icon.split(':');
+                const PascalIconName = 'Icon' + iconName.split('-').map((part, index) => {
+                    return part[0].toUpperCase() + part.slice(1);
+                }).join('');
+                return `app.component('${PascalIconName}', ${PascalIconName});`;
+            }).join('\n');
+            let imports = iconImports + '\n';
+            if ((_c = this.adminforth.config.customization) === null || _c === void 0 ? void 0 : _c.vueUsesFile) {
+                imports += `import addCustomUses from '${this.adminforth.config.customization.vueUsesFile}';\n`;
+            }
+            // inject that code into spa_tmp/src/App.vue
+            const appVuePath = path.join(spaTmpPath, 'src', 'main.ts');
+            let appVueContent = yield fs.promises.readFile(appVuePath, 'utf-8');
+            appVueContent = appVueContent.replace('/* IMPORTANT:ADMINFORTH IMPORTS */', imports);
+            appVueContent = appVueContent.replace('/* IMPORTANT:ADMINFORTH COMPONENT REGISTRATIONS */', iconComponents + '\n');
+            if ((_d = this.adminforth.config.customization) === null || _d === void 0 ? void 0 : _d.vueUsesFile) {
+                appVueContent = appVueContent.replace('/* IMPORTANT:ADMINFORTH CUSTOM USES */', 'addCustomUses(app);');
+            }
+            yield fs.promises.writeFile(appVuePath, appVueContent);
+            /* generate custom rotes */
+            const routerVuePath = path.join(spaTmpPath, 'src', 'router', 'index.ts');
+            let routerVueContent = yield fs.promises.readFile(routerVuePath, 'utf-8');
+            routerVueContent = routerVueContent.replace('/* IMPORTANT:ADMINFORTH ROUTES */', routes);
+            yield fs.promises.writeFile(routerVuePath, routerVueContent);
+            /* hash checking */
+            const packageLockPath = path.join(spaTmpPath, 'package-lock.json');
+            const packageLock = JSON.parse(yield fs.promises.readFile(packageLockPath, 'utf-8'));
+            const lockHash = hashify(packageLock);
+            /* customPackageLock */
+            const customPackagePath = path.join('./package.json');
+            const customPackage = JSON.parse(yield fs.promises.readFile(customPackagePath, 'utf-8'));
+            const customPackageHash = hashify(customPackage);
+            const customLockPath = path.join('./package-lock.json');
+            const customLock = JSON.parse(yield fs.promises.readFile(customLockPath, 'utf-8'));
+            const customLockHash = hashify(customLock);
+            const packagesNamesHash = hashify(packageNames);
+            const fullHash = hashify([lockHash, packagesNamesHash, customLockHash]);
+            const hashPath = path.join(spaTmpPath, 'node_modules', '.adminforth_hash');
+            try {
+                const existingHash = yield fs.promises.readFile(hashPath, 'utf-8');
+                if (existingHash === fullHash) {
+                    console.log('Hashes match, skipping npm ci/install');
+                    return;
+                }
+            }
+            catch (e) {
+                // ignore
+            }
+            yield this.runNpmShell({ command: 'ci', verbose, cwd: spaTmpPath });
+            // get packages with version from customPackage
+            const customPackgeNames = [...Object.keys(customPackage.dependencies), ...Object.keys(customPackage.devDependencies || [])].reduce((acc, packageName) => {
+                const version = customLock.packages[`node_modules/${packageName}`].version;
+                acc.push(`${packageName}@${version}`);
+                return acc;
+            }, []);
+            if (packageNames.length) {
+                const npmInstallCommand = `install ${[...packageNames, ...customPackgeNames].join(' ')}`;
+                yield this.runNpmShell({ command: npmInstallCommand, cwd: spaTmpPath });
+            }
+            yield fs.promises.writeFile(hashPath, fullHash);
+        });
+    }
+    watchForReprepare(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ verbose }) {
+            const spaPath = path.join(__dirname, 'spa');
+            // get list of all subdirectories in spa recursively
+            const directories = [];
+            const collectDirectories = (dir) => __awaiter(this, void 0, void 0, function* () {
+                const files = yield fs.promises.readdir(dir, { withFileTypes: true });
+                for (const file of files) {
+                    if (file.isDirectory() && ['node_modules', 'dist'].indexOf(file.name) === -1) {
+                        directories.push(path.join(dir, file.name));
+                        yield collectDirectories(path.join(dir, file.name));
+                    }
+                }
+            });
+            yield collectDirectories(spaPath);
+            if (verbose) {
+                console.log('🔎 Watching for changes in:', directories.join(','));
+            }
+            const watcher = filewatcher();
+            directories.forEach((dir) => {
+                watcher.add(dir);
+            });
+            watcher.on('change', (file) => __awaiter(this, void 0, void 0, function* () {
+                console.log(`File ${file} changed, preparing sources...`);
+                yield this.prepareSources({ filesUpdated: [file.replace(spaPath + '/', '')] });
+            }));
+            process.on('exit', () => {
+                watcher.removeAll();
+            });
+        });
+    }
+    watchCustomComponentsForCopy(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ verbose }) {
+            const customComponentsDir = this.adminforth.config.customization.customComponentsDir;
+            // check if folder exists
+            try {
+                yield fs.promises.access(customComponentsDir, fs.constants.F_OK);
+            }
+            catch (e) {
+                if (verbose) {
+                    console.log(`Custom components dir ${customComponentsDir} does not exist, skipping watching`);
+                }
+                return;
+            }
+            // get all subdirs
+            const directories = [];
+            const collectDirectories = (dir) => __awaiter(this, void 0, void 0, function* () {
+                directories.push(dir);
+                const files = yield fs.promises.readdir(dir, { withFileTypes: true });
+                for (const file of files) {
+                    if (file.isDirectory()) {
+                        yield collectDirectories(path.join(dir, file.name));
+                    }
+                }
+            });
+            yield collectDirectories(customComponentsDir);
+            const watcher = filewatcher();
+            directories.forEach((dir) => {
+                watcher.add(dir);
+            });
+            if (verbose) {
+                console.log('🔎 Watching for changes in:', directories.join(','));
+            }
+            watcher.on('change', (file) => __awaiter(this, void 0, void 0, function* () {
+                // copy one file
+                // TODO: non optimal, copy only changed file, test on both nested and parent dir
+                if (verbose) {
+                    console.log(`🔎 File ${file} changed, copying to spa_tmp...`);
+                }
+                yield fsExtra.copy(this.adminforth.config.customization.customComponentsDir, path.join(CodeInjector.SPA_TMP_PATH, 'src', 'custom'), {
+                    recursive: true,
+                });
+            }));
+            process.on('exit', () => {
+                watcher.removeAll();
+            });
+        });
+    }
+    bundleNow(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ hotReload = false, verbose = false }) {
+            this.adminforth.runningHotReload = hotReload;
+            yield this.prepareSources({ verbose });
+            if (hotReload) {
+                yield this.watchForReprepare({ verbose });
+                yield this.watchCustomComponentsForCopy({ verbose });
+            }
+            console.log('AdminForth bundling');
+            const cwd = CodeInjector.SPA_TMP_PATH;
+            if (!hotReload) {
+                // probably add option to build with tsh check (plain 'build')
+                yield this.runNpmShell({ command: 'run build-only', verbose, cwd });
+            }
+            else {
+                const command = 'run dev';
+                console.log(`⚙️ Running npm ${command}...`);
+                const nodeBinary = process.execPath;
+                const npmPath = path.join(path.dirname(nodeBinary), 'npm');
+                const env = Object.assign({ VUE_APP_ADMINFORTH_PUBLIC_PATH: this.adminforth.config.baseUrl, FORCE_COLOR: '1' }, process.env);
+                const devServer = spawn(`${nodeBinary}`, [`${npmPath}`, ...command.split(' ')], {
+                    cwd,
+                    env,
+                });
+                devServer.stdout.on('data', (data) => {
+                    console.log(`[AdminForth SPA]:`);
+                    process.stdout.write(data);
+                });
+                devServer.stderr.on('data', (data) => {
+                    console.error(`[AdminForth SPA ERR]:`);
+                    process.stdout.write(data);
+                });
+            }
+        });
+    }
+}
+CodeInjector.SPA_TMP_PATH = path.join(TMP_DIR, 'adminforth', 'spa_tmp');
+export default CodeInjector;

package/dist/modules/utils.js

@@ -0,0 +1,12 @@
+export function guessLabelFromName(name) {
+    if (name.includes('_')) {
+        return name.split('_').map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(' ');
+    }
+    else if (name.includes('-')) {
+        return name.split('-').map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(' ');
+    }
+    else {
+        // split by capital letters
+        return name.split(/(?=[A-Z])/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(' ');
+    }
+}

package/dist/servers/express.js

@@ -0,0 +1,210 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs';
+import CodeInjector from '../modules/codeInjector.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+function replaceAtStart(string, substring) {
+    if (string.startsWith(substring)) {
+        return string.slice(substring.length);
+    }
+    return string;
+}
+function proxyTo(url, res) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const r = yield fetch(url);
+        const body = yield r.text();
+        res.status(r.status);
+        r.headers.forEach((value, name) => {
+            res.setHeader(name, value);
+        });
+        res.send(body);
+    });
+}
+function parseExpressCookie(req) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const cookies = req.headers.cookie;
+        if (!cookies) {
+            return {};
+        }
+        const parts = cookies.split('; ');
+        const result = {};
+        parts.forEach(part => {
+            const [key, value] = part.split('=');
+            result[key] = value;
+        });
+        return result;
+    });
+}
+const respondNoServer = (title, explanation) => {
+    return `
+    <!DOCTYPE html>
+    <html lang="en">
+    <head>
+      <meta charset="UTF-8">
+      <meta http-equiv="X-UA-Compatible" content="IE=edge">
+      <meta name="viewport" content="width=device-width, initial-scale=1.0">
+      <title>AdminForth</title>
+    </head>
+    <body>
+      <div class="center">
+        <h1>Oops!</h1>
+        <h2>${title}</h2>
+        <p>${explanation}</p>
+      </div>
+      <style>
+        body {
+          font-family: Arial, sans-serif;
+          background-color: #f0f0f0;
+          margin: 0;
+          padding: 0;
+        }
+        .center {
+          display: flex;
+          justify-content: center;
+          align-items: center;
+          height: 100vh;
+          flex-direction: column;
+        }
+      </style>
+      <script>
+        setTimeout(() => {
+          location.reload();
+        }, 1500);
+      </script>
+    </body>
+    `;
+};
+class ExpressServer {
+    constructor(adminforth) {
+        this.adminforth = adminforth;
+    }
+    setupSpaServer() {
+        const prefix = this.adminforth.config.baseUrl;
+        const slashedPrefix = prefix.endsWith('/') ? prefix : `${prefix}/`;
+        if (this.adminforth.runningHotReload) {
+            const handler = (req, res) => __awaiter(this, void 0, void 0, function* () {
+                // proxy using fetch to webpack dev server
+                try {
+                    yield proxyTo(`http://localhost:5173${req.url}`, res);
+                }
+                catch (e) {
+                    res.status(500).send(respondNoServer('AdminForth SPA is not ready yet', 'Vite is still starting up. Please wait a moment...'));
+                    return;
+                }
+            });
+            this.expressApp.get(`${slashedPrefix}assets/*`, handler);
+            this.expressApp.get(`${prefix}*`, handler);
+        }
+        else {
+            this.expressApp.get(`${slashedPrefix}assets/*`, (req, res) => {
+                res.sendFile(path.join(CodeInjector.SPA_TMP_PATH, 'dist', replaceAtStart(req.url, prefix)));
+            });
+            this.expressApp.get(`${prefix}*`, (req, res) => __awaiter(this, void 0, void 0, function* () {
+                const fullPath = path.join(CodeInjector.SPA_TMP_PATH, 'dist', 'index.html');
+                let fileExists = true;
+                try {
+                    yield fs.promises.access(fullPath, fs.constants.F_OK);
+                }
+                catch (e) {
+                    fileExists = false;
+                }
+                if (!fileExists) {
+                    res.status(500).send(respondNoServer(`${this.adminforth.config.brandName} is still warming up`, 'Please wait a moment...'));
+                    return;
+                }
+                res.sendFile(fullPath);
+            }));
+        }
+    }
+    serve(app) {
+        this.expressApp = app;
+        this.adminforth.setupEndpoints(this);
+        this.setupSpaServer();
+    }
+    authorize(handler) {
+        return (req, res, next) => __awaiter(this, void 0, void 0, function* () {
+            const cookies = yield parseExpressCookie(req);
+            const jwt = cookies['adminforth_jwt'];
+            if (!jwt) {
+                res.status(401).send('Unauthorized by AdminForth');
+                return;
+            }
+            const adminforthUser = this.adminforth.auth.verify(jwt);
+            if (!adminforthUser) {
+                res.status(401).send('Unauthorized by AdminForth');
+            }
+            else {
+                req.adminUser = adminforthUser;
+                handler(req, res, next);
+            }
+        });
+    }
+    endpoint({ method = 'GET', path, handler, noAuth = false }) {
+        if (!path.startsWith('/')) {
+            throw new Error(`Path must start with /, got: ${path}`);
+        }
+        const fullPath = `${this.adminforth.config.baseUrl}/adminapi/v1${path}`;
+        const expressHandler = (req, res) => __awaiter(this, void 0, void 0, function* () {
+            let body = req.body || {};
+            if (typeof body === 'string') {
+                try {
+                    body = JSON.parse(body);
+                }
+                catch (e) {
+                    console.error('Failed to parse body', e);
+                    res.status(400).send('Invalid JSON body');
+                }
+            }
+            const query = req.query;
+            const adminUser = req.adminUser;
+            const headers = req.headers;
+            const cookies = yield parseExpressCookie(req);
+            const response = {
+                headers: {},
+                status: 200,
+                message: undefined,
+                setHeader(name, value) {
+                    this.headers[name] = value;
+                },
+                setStatus(code, message) {
+                    this.status = code;
+                    this.message = message;
+                }
+            };
+            const input = { body, query, headers, cookies, response, _raw_express_req: req, _raw_express_res: res };
+            let output;
+            try {
+                output = yield handler(input);
+            }
+            catch (e) {
+                console.error('Error in handler', e);
+                // print full stack trace 
+                console.error(e.stack);
+                res.status(500).send('Internal server error');
+                return;
+            }
+            Object.keys(response.headers).forEach((name) => {
+                res.setHeader(name, response.headers[name]);
+            });
+            const resp = res.status(response.status);
+            if (response.message) {
+                resp.send(response.message);
+                return;
+            }
+            res.json(output);
+        });
+        console.log(`Adding endpoint ${method} ${fullPath}`);
+        this.expressApp[method.toLowerCase()](fullPath, noAuth ? expressHandler : this.authorize(expressHandler));
+    }
+}
+export default ExpressServer;

package/dist/spa/src/main.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vue_1 = require("vue");
+const pinia_1 = require("pinia");
+/* IMPORTANT:ADMINFORTH IMPORTS */
+const App_vue_1 = __importDefault(require("./App.vue"));
+const router_1 = __importDefault(require("./router"));
+const app = (0, vue_1.createApp)(App_vue_1.default);
+/* IMPORTANT:ADMINFORTH COMPONENT REGISTRATIONS */
+app.use((0, pinia_1.createPinia)());
+app.use(router_1.default);
+/* IMPORTANT:ADMINFORTH CUSTOM USES */
+app.mount('#app');

package/dist/spa/src/router/index.js

@@ -0,0 +1,79 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vue_router_1 = require("vue-router");
+const HomeView_vue_1 = __importDefault(require("../views/HomeView.vue"));
+const ResourceParent_vue_1 = __importDefault(require("@/views/ResourceParent.vue"));
+const ListView_vue_1 = __importDefault(require("@/views/ListView.vue"));
+const ShowView_vue_1 = __importDefault(require("@/views/ShowView.vue"));
+const EditView_vue_1 = __importDefault(require("@/views/EditView.vue"));
+const CreateView_vue_1 = __importDefault(require("@/views/CreateView.vue"));
+const router = (0, vue_router_1.createRouter)({
+    history: (0, vue_router_1.createWebHistory)(import.meta.env.BASE_URL),
+    routes: [
+        {
+            path: '/',
+            name: 'home',
+            component: HomeView_vue_1.default
+        },
+        {
+            path: '/login',
+            name: 'login',
+            component: () => Promise.resolve().then(() => __importStar(require('@/views/LoginView.vue')))
+        },
+        {
+            path: '/resource/:resourceId',
+            component: ResourceParent_vue_1.default,
+            name: 'resource',
+            children: [
+                {
+                    path: '',
+                    component: ListView_vue_1.default,
+                    name: 'resource-list'
+                },
+                {
+                    path: 'show/:primaryKey',
+                    component: ShowView_vue_1.default,
+                    name: 'resource-show'
+                },
+                {
+                    path: 'edit/:primaryKey',
+                    component: EditView_vue_1.default,
+                    name: 'resource-edit'
+                },
+                {
+                    path: 'create',
+                    component: CreateView_vue_1.default,
+                    name: 'resource-create'
+                },
+            ]
+        },
+        /* IMPORTANT:ADMINFORTH ROUTES */
+    ]
+});
+exports.default = router;