nextjs-cms 0.6.8 → 0.7.0

package/dist/cli/commands/db-config.d.ts

@@ -0,0 +1,2 @@
+export declare function runDbConfig(dev: boolean): Promise<void>;
+//# sourceMappingURL=db-config.d.ts.map

package/dist/cli/commands/db-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db-config.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/db-config.ts"],"names":[],"mappings":"AAGA,wBAAsB,WAAW,CAAC,GAAG,EAAE,OAAO,iBAiB7C"}

package/dist/cli/commands/db-config.js

@@ -0,0 +1,22 @@
+import chalk from 'chalk';
+import * as p from '@clack/prompts';
+export async function runDbConfig(dev) {
+    let exitCode = 0;
+    try {
+        p.log.info(chalk.cyan('Configuring database'));
+        // Lazy import to avoid eager database connection
+        const { dbConfigSetup } = await import('../lib/db-config.js');
+        await dbConfigSetup({ dev });
+        p.outro(chalk.inverse(' ✓ Database configuration completed '));
+    }
+    catch (error) {
+        console.error(chalk.red('✗ Error during database configuration:'), error);
+        exitCode = 1;
+    }
+    finally {
+        // Lazy import for cleanup
+        const { dbConnectionClose } = await import('../../db/client.js');
+        await dbConnectionClose();
+    }
+    process.exit(exitCode);
+}

package/dist/cli/commands/fix-master-admin.d.ts

@@ -0,0 +1,2 @@
+export declare function runFixMasterAdmin(): Promise<void>;
+//# sourceMappingURL=fix-master-admin.d.ts.map

package/dist/cli/commands/fix-master-admin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fix-master-admin.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/fix-master-admin.ts"],"names":[],"mappings":"AAGA,wBAAsB,iBAAiB,kBAiBtC"}

package/dist/cli/commands/fix-master-admin.js

@@ -0,0 +1,22 @@
+import chalk from 'chalk';
+import * as p from '@clack/prompts';
+export async function runFixMasterAdmin() {
+    let exitCode = 0;
+    try {
+        p.log.info(chalk.cyan('Looking up sections'));
+        // Lazy import to avoid eager database connection
+        const { fixMasterAdminPrivileges } = await import('../lib/fix-master-admin.js');
+        await fixMasterAdminPrivileges();
+        p.outro(chalk.inverse(' ✓ Master admin privileges fixed '));
+    }
+    catch (error) {
+        console.error(chalk.red('Error fixing master admin privileges:'), error);
+        exitCode = 1;
+    }
+    finally {
+        // Lazy import for cleanup
+        const { dbConnectionClose } = await import('../../db/client.js');
+        await dbConnectionClose();
+    }
+    process.exit(exitCode);
+}

package/dist/cli/commands/set-master-admin.d.ts

@@ -0,0 +1,2 @@
+export declare function runSetMasterAdmin(): Promise<void>;
+//# sourceMappingURL=set-master-admin.d.ts.map

package/dist/cli/commands/set-master-admin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-master-admin.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/set-master-admin.ts"],"names":[],"mappings":"AAGA,wBAAsB,iBAAiB,kBAoBtC"}

package/dist/cli/commands/set-master-admin.js

@@ -0,0 +1,25 @@
+import chalk from 'chalk';
+import * as p from '@clack/prompts';
+export async function runSetMasterAdmin() {
+    p.log.info(chalk.cyan('Setting up master admin'));
+    let exitCode = 0;
+    try {
+        const { setMasterAdmin } = await import('../lib/set-master-admin.js');
+        await setMasterAdmin();
+        p.outro(chalk.inverse(' ✓ Master admin setup completed successfully '));
+    }
+    catch (error) {
+        p.log.error(chalk.red('✗ Error resetting master admin:'));
+        console.error(error);
+        // Lazy import for cleanup
+        const { dbConnectionClose } = await import('../../db/client.js');
+        await dbConnectionClose();
+        exitCode = 1;
+    }
+    finally {
+        // Lazy import for cleanup
+        const { dbConnectionClose } = await import('../../db/client.js');
+        await dbConnectionClose();
+    }
+    process.exit(exitCode);
+}

package/dist/cli/commands/setup.d.ts

@@ -0,0 +1,2 @@
+export declare function runSetup(dev: boolean, skipDbConfig: boolean): Promise<void>;
+//# sourceMappingURL=setup.d.ts.map

package/dist/cli/commands/setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/setup.ts"],"names":[],"mappings":"AAGA,wBAAsB,QAAQ,CAAC,GAAG,EAAE,OAAO,EAAE,YAAY,EAAE,OAAO,iBAiCjE"}

package/dist/cli/commands/setup.js

@@ -0,0 +1,34 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+export async function runSetup(dev, skipDbConfig) {
+    let exitCode = 0;
+    try {
+        if (!skipDbConfig) {
+            p.log.info(chalk.cyan('Configuring database'));
+            const { dbConfigSetup } = await import('../lib/db-config.js');
+            await dbConfigSetup({ dev });
+        }
+        p.log.info(chalk.cyan('Generating database tables'));
+        const { generateDatabaseTables } = await import('../lib/db-migrate.js');
+        await generateDatabaseTables();
+        p.log.info(chalk.cyan('Setting up master admin'));
+        const { setMasterAdmin } = await import('../lib/set-master-admin.js');
+        await setMasterAdmin();
+        p.outro(chalk.inverse(' ✓ nextjs-cms setup completed successfully '));
+    }
+    catch (error) {
+        console.log('');
+        console.error(chalk.red('✗ Error during setup:'), error);
+        p.outro(chalk.red('✗ Setup failed'));
+        // Lazy import for cleanup
+        const { dbConnectionClose } = await import('../../db/client.js');
+        await dbConnectionClose();
+        exitCode = 1;
+    }
+    finally {
+        // Lazy import for cleanup
+        const { dbConnectionClose } = await import('../../db/client.js');
+        await dbConnectionClose();
+    }
+    process.exit(exitCode);
+}

package/dist/cli/commands/update-sections.d.ts

@@ -0,0 +1,2 @@
+export declare function runUpdateSections(dev: boolean): Promise<void>;
+//# sourceMappingURL=update-sections.d.ts.map

package/dist/cli/commands/update-sections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-sections.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/update-sections.ts"],"names":[],"mappings":"AAGA,wBAAsB,iBAAiB,CAAC,GAAG,EAAE,OAAO,iBAsBnD"}

package/dist/cli/commands/update-sections.js

@@ -0,0 +1,27 @@
+import chalk from 'chalk';
+import * as p from '@clack/prompts';
+export async function runUpdateSections(dev) {
+    let exitCode = 0;
+    try {
+        p.log.info(chalk.cyan('Updating sections'));
+        const { updateSections } = await import('../lib/update-sections.js');
+        await updateSections(dev);
+        p.log.info(chalk.cyan('Modifying master admin privileges'));
+        // Lazy import to avoid eager database connection
+        const { fixMasterAdminPrivileges } = await import('../lib/fix-master-admin.js');
+        await fixMasterAdminPrivileges();
+        p.log.message(chalk.green(' - ✓ Master admin privileges fixed.'));
+        p.outro(chalk.inverse(' ✓ Sections updated '));
+    }
+    catch (error) {
+        p.log.error(chalk.red('✗ Error updating sections:'));
+        console.error(error);
+        exitCode = 1;
+    }
+    finally {
+        // Lazy import for cleanup
+        const { dbConnectionClose } = await import('../../db/client.js');
+        await dbConnectionClose();
+    }
+    process.exit(exitCode);
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":""}

package/dist/cli/index.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import dotenv from 'dotenv';
+import program from './program/program.js';
+program.parse(process.argv);
+// Load environment file based on parsed dev flag
+if (Boolean(program.opts().dev) === true) {
+    dotenv.config({ path: '.env.development', quiet: true });
+    // @ts-expect-error -- CLI intentionally sets NODE_ENV before app code runs
+    process.env.NODE_ENV = 'development';
+}
+else {
+    dotenv.config();
+    // @ts-expect-error -- CLI intentionally sets NODE_ENV before app code runs
+    process.env.NODE_ENV = 'production';
+}

package/dist/cli/lib/db-config.d.ts

@@ -0,0 +1,4 @@
+export declare function dbConfigSetup(options: {
+    dev: boolean;
+}): Promise<void>;
+//# sourceMappingURL=db-config.d.ts.map

package/dist/cli/lib/db-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db-config.d.ts","sourceRoot":"","sources":["../../../src/cli/lib/db-config.ts"],"names":[],"mappings":"AAmCA,wBAAsB,aAAa,CAAC,OAAO,EAAE;IAAE,GAAG,EAAE,OAAO,CAAA;CAAE,iBAyO5D"}

package/dist/cli/lib/db-config.js

@@ -0,0 +1,238 @@
+import { createConnection } from 'mysql2/promise';
+import * as p from '@clack/prompts';
+import fs from 'fs';
+import path from 'path';
+import { cwd } from 'process';
+import chalk from 'chalk';
+import ora from 'ora';
+/**
+ * Removes specific environment variables from the .env file content
+ * Removes both the generated comment block and the individual variable lines
+ */
+function removeEnvVariables(content, variables) {
+    let result = content;
+    // Remove the generated block comment if it exists (including the markers)
+    const blockRegex = /\n*####\s*\n#\s*generated by the init script\s*\n####\s*\n?/g;
+    result = result.replace(blockRegex, '\n');
+    // Remove individual variable lines (entire lines including newline)
+    variables.forEach((variable) => {
+        result = result.replace(new RegExp(`^${variable}=.*$\\n?`, 'gm'), '');
+    });
+    return result;
+}
+/**
+ * Validates if a string is a valid port number
+ */
+function isValidPort(value) {
+    const port = parseInt(value, 10);
+    return !isNaN(port) && port > 0 && port <= 65535;
+}
+export async function dbConfigSetup(options) {
+    const { dev = false } = options;
+    const envFileName = dev ? '.env.development' : '.env.production';
+    /**
+     * Step 1: Ask for connection credentials
+     */
+    p.log.info('Database Connection');
+    p.log.message('Please provide your MySQL/MariaDB server credentials');
+    const { dbHost, dbPort, dbUser, dbPassword } = await p.group({
+        dbHost: () => p.text({
+            message: 'Database host:',
+            placeholder: 'localhost',
+            defaultValue: 'localhost',
+            validate(value) {
+                if (value && value.length < 2)
+                    return `Database host must be at least 2 characters`;
+            },
+        }),
+        dbPort: () => p.text({
+            message: 'Database port:',
+            placeholder: '3306',
+            defaultValue: '3306',
+            validate(value) {
+                if (value && !isValidPort(value)) {
+                    return `Database port must be a valid number between 1 and 65535`;
+                }
+            },
+        }),
+        dbUser: () => p.text({
+            message: 'Database username:',
+            validate(value) {
+                if (value.length < 1)
+                    return `Database username is required`;
+            },
+        }),
+        dbPassword: () => p.text({
+            message: 'Database password:',
+            validate(value) {
+                if (value.length < 1)
+                    return `Database password is required`;
+            },
+        }),
+    }, {
+        onCancel: () => {
+            p.cancel(`Aborted\n`);
+            process.exit(1);
+        },
+    });
+    /**
+     * Step 2: Test the database connection
+     */
+    const s = ora('Testing database connection...').start();
+    let migrationClient;
+    try {
+        /**
+         * It's recommended to not use a pool connection for migrations, that's why we're creating a new connection here.
+         */
+        migrationClient = await createConnection({
+            host: String(dbHost),
+            user: String(dbUser),
+            password: String(dbPassword),
+            database: '',
+            port: parseInt(String(dbPort), 10),
+        });
+        s.stop();
+        p.log.success(chalk.green('✓ Connected successfully!'));
+        /**
+         * Step 3: Now that connection is successful, ask for database name
+         */
+        const dbName = await p.text({
+            message: 'Database name:',
+            placeholder: 'If the database does not exist, it will be created',
+            validate(value) {
+                if (value.length < 2)
+                    return `Database name must be at least 2 characters`;
+                // Validate database name format (alphanumeric, underscore, hyphen)
+                if (!/^[a-zA-Z0-9_-]+$/.test(value)) {
+                    return `Database name can only contain letters, numbers, underscores, and hyphens`;
+                }
+            },
+        });
+        if (p.isCancel(dbName)) {
+            p.cancel(`Aborted\n`);
+            process.exit(1);
+        }
+        /**
+         * Step 4: Create the database
+         */
+        s.start('Creating database...');
+        /**
+         * Let's create the database using parameterized query to prevent SQL injection
+         */
+        await migrationClient.query('CREATE DATABASE IF NOT EXISTS ??', [dbName]);
+        s.stop();
+        p.log.success(chalk.green('✓ Database created successfully!'));
+        /**
+         * Let's save the database credentials in the .env file
+         */
+        const envPath = path.resolve(cwd(), envFileName);
+        /**
+         * If the .env file does not exist, we'll create it
+         */
+        if (!fs.existsSync(envPath)) {
+            fs.writeFileSync(envPath, '');
+        }
+        /**
+         * Read current .env content and remove existing database credentials
+         */
+        let currentEnv = fs.readFileSync(envPath, 'utf8');
+        currentEnv = removeEnvVariables(currentEnv, ['DB_HOST', 'DB_PORT', 'DB_NAME', 'DB_USER', 'DB_PASSWORD']);
+        /**
+         * Prepare new environment variables block
+         */
+        const newEnvBlock = `
+
+####
+# generated by the init script
+####
+DB_HOST=${dbHost}
+DB_PORT=${dbPort}
+DB_NAME=${dbName}
+DB_USER=${dbUser}
+DB_PASSWORD='${dbPassword}'
+`;
+        /**
+         * Append the new credentials to the .env file
+         */
+        let finalEnv = currentEnv + newEnvBlock;
+        // Trim multiple consecutive empty lines to a maximum of two empty lines
+        finalEnv = finalEnv.replace(/(\n\s*\n){3,}/g, '\n\n');
+        // Trim leading whitespace
+        finalEnv = finalEnv.trim() + '\n';
+        fs.writeFileSync(envPath, finalEnv);
+        // Reload environment variables after writing to .env file
+        const dbVariables = {
+            DB_HOST: String(dbHost),
+            DB_PORT: String(dbPort),
+            DB_NAME: String(dbName),
+            DB_USER: String(dbUser),
+            DB_PASSWORD: String(dbPassword),
+        };
+        const { reloadAndUpdateEnvironmentVariables } = await import('../utils/reload-env.js');
+        reloadAndUpdateEnvironmentVariables(dbVariables, envFileName);
+        /**
+         * Get environment variables from env and check if they are correct
+         */
+        const envDbHost = process.env.DB_HOST;
+        const envDbPort = process.env.DB_PORT;
+        const envDbName = process.env.DB_NAME;
+        const envDbUser = process.env.DB_USER;
+        const envDbPassword = process.env.DB_PASSWORD;
+        // Validate that the values match what we just set
+        const mismatches = [];
+        if (envDbHost !== String(dbHost))
+            mismatches.push('DB_HOST');
+        if (envDbPort !== String(dbPort))
+            mismatches.push('DB_PORT');
+        if (envDbName !== String(dbName))
+            mismatches.push('DB_NAME');
+        if (envDbUser !== String(dbUser))
+            mismatches.push('DB_USER');
+        if (envDbPassword !== String(dbPassword))
+            mismatches.push('DB_PASSWORD');
+        if (mismatches.length > 0) {
+            p.log.error(`✗ Couldn't save database credentials to ${envFileName} file}`);
+            console.error(`Please save these values manually to the ${envFileName} file:`);
+            console.error(`DB_HOST: ${dbHost}`);
+            console.error(`DB_PORT: ${dbPort}`);
+            console.error(`DB_NAME: ${dbName}`);
+            console.error(`DB_USER: ${dbUser}`);
+            console.error(`DB_PASSWORD: ${dbPassword}`);
+            console.error();
+            console.error(chalk.cyan(`and then run: ${chalk.green(`pnpm nextjs-cms ${dev ? '-d' : ''} setup --continue`)} to continue your setup`));
+            process.exit(1);
+        }
+        p.log.message(chalk.cyan(` - Saved database credentials to ${envFileName} file`));
+    }
+    catch (error) {
+        s.stop();
+        p.log.error(chalk.red('✗ Database setup failed!'));
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorCode = error && typeof error === 'object' && 'code' in error ? error.code : null;
+        // Provide specific error messages based on error type
+        if (errorCode === 'ER_ACCESS_DENIED_ERROR' || errorCode === 'ECONNREFUSED') {
+            console.error('\n❌ Connection Error:', errorMessage);
+            console.error('\nPlease verify:');
+            console.error('  • Database host and port are correct');
+            console.error('  • Username and password are correct');
+            console.error('  • Database server is running');
+            console.error('  • User has sufficient privileges');
+        }
+        else if (errorCode === 'ER_BAD_DB_ERROR') {
+            console.error('\n❌ Database Error:', errorMessage);
+        }
+        else {
+            console.error('\n❌ Error:', errorMessage);
+        }
+        p.outro(`\nSetup failed. Please check the errors above and try again.`);
+        process.exit(1);
+    }
+    finally {
+        /**
+         * Always close the connection, even if an error occurred
+         */
+        if (migrationClient) {
+            await migrationClient.end();
+        }
+    }
+}

package/dist/cli/lib/db-migrate.d.ts

@@ -0,0 +1,2 @@
+export declare function generateDatabaseTables(): Promise<void>;
+//# sourceMappingURL=db-migrate.d.ts.map

package/dist/cli/lib/db-migrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db-migrate.d.ts","sourceRoot":"","sources":["../../../src/cli/lib/db-migrate.ts"],"names":[],"mappings":"AAOA,wBAAsB,sBAAsB,kBAoF3C"}

package/dist/cli/lib/db-migrate.js

@@ -0,0 +1,83 @@
+import * as p from '@clack/prompts';
+import { execWithSpinner } from '../utils/exec-utils.js';
+import chalk from 'chalk';
+import { MysqlTableChecker } from '../../core/db/index.js';
+import { db } from '../../db/client.js';
+import { sql } from '../../db/index.js';
+export async function generateDatabaseTables() {
+    /**
+     * We should first drop all primary keys from the tables
+     */
+    const _existingTables = [];
+    const tablesToCheck = [
+        '__nextjs_cms_tables',
+        'admins',
+        'admin_privileges',
+        'access_tokens',
+        'editor_photos',
+    ];
+    try {
+        const result = await MysqlTableChecker.getExistingTables();
+        result.forEach((table) => {
+            if (tablesToCheck.includes(table)) {
+                _existingTables.push(table);
+            }
+        });
+        if (_existingTables.length > 0) {
+            const allOrSome = _existingTables.length === tablesToCheck.length ? 'all' : 'some';
+            p.log.warn(chalk.yellow(`You already have ${allOrSome === 'some' ? 'a few required tables from' : ''} a previous database schema:`));
+            for (const table of _existingTables) {
+                p.log.message(chalk.yellow(`  - ${table}`));
+            }
+            p.log.message(chalk.cyan('These tables will be dropped and new ones will be created.'));
+            const answer = await p.select({
+                message: 'Do you want to continue? (y/n)',
+                options: [
+                    { value: 'y', label: 'Yes' },
+                    { value: 'n', label: 'No' },
+                ],
+                initialValue: 'n',
+            });
+            if (p.isCancel(answer) || answer !== 'y') {
+                p.log.error(chalk.red('Aborted\n'));
+                process.exit(1);
+            }
+            try {
+                // Disable foreign key checks to allow dropping tables with foreign key constraints
+                await db.execute(sql `SET FOREIGN_KEY_CHECKS = 0`);
+                // Drop all tables at once
+                for (const table of _existingTables) {
+                    await db.execute(sql `DROP TABLE IF EXISTS \`${sql.raw(table)}\``);
+                }
+                // Re-enable foreign key checks
+                await db.execute(sql `SET FOREIGN_KEY_CHECKS = 1`);
+            }
+            catch (error) {
+                // Re-enable foreign key checks even if there's an error
+                await db.execute(sql `SET FOREIGN_KEY_CHECKS = 1`).catch(() => {
+                    // Ignore errors when re-enabling
+                });
+                console.error(chalk.red('✗ Error dropping existing tables:'), error);
+                p.log.error(chalk.red('✗ Failed to drop existing tables'));
+                throw error;
+            }
+        }
+        const spinner = await execWithSpinner({
+            command: 'pnpm',
+            args: ['drizzle-kit', 'push', '--force', '--config=drizzle.config.ts'],
+            cwd: process.cwd(),
+            stdout: 'pipe', // Show output
+            stderr: 'inherit', // Show errors
+            spinnerText: 'Generating database tables...',
+            checkExitCode: true, // Throw on non-zero exit codes
+            checkStderrForErrors: true, // Also check for errors in output even if exit code is 0
+        });
+        spinner?.stop();
+        p.log.success(chalk.green(' ✓ Database tables generated'));
+    }
+    catch (error) {
+        console.error(chalk.red(' ✗ Error generating database tables:'), error);
+        p.log.error(chalk.red('✗ Failed to generate database tables'));
+        process.exit(1);
+    }
+}

package/dist/cli/lib/fix-master-admin.d.ts

@@ -0,0 +1,2 @@
+export declare function fixMasterAdminPrivileges(): Promise<void>;
+//# sourceMappingURL=fix-master-admin.d.ts.map

package/dist/cli/lib/fix-master-admin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fix-master-admin.d.ts","sourceRoot":"","sources":["../../../src/cli/lib/fix-master-admin.ts"],"names":[],"mappings":"AAEA,wBAAsB,wBAAwB,kBA2D7C"}

package/dist/cli/lib/fix-master-admin.js

@@ -0,0 +1,53 @@
+import { getPluginRoutes } from '../../plugins/server.js';
+export async function fixMasterAdminPrivileges() {
+    // Lazy import heavy dependencies to avoid eager database connection initialization
+    const { SectionFactory } = await import('../../core/factories/index.js');
+    const { db } = await import('../../db/client.js');
+    const { AdminPrivilegesTable } = await import('../../db/schema.js');
+    // Let's also add privileges for all the sections to the master admin
+    // Loop through the sections to get the section ids for the insertion into the admin_privileges table
+    const sections = await SectionFactory.getSectionsSilently();
+    const rows = sections.map((section) => ({
+        adminId: '1',
+        sectionName: section.name,
+        operations: 'CUD',
+        publisher: '1',
+    }));
+    const pluginRoutes = await getPluginRoutes();
+    const pluginNames = new Set(pluginRoutes.map((route) => {
+        return route.pluginName;
+    }));
+    pluginNames.forEach((pluginName) => {
+        rows.push({
+            adminId: '1',
+            sectionName: pluginName,
+            operations: 'CUD',
+            publisher: '1',
+        });
+    });
+    /**
+     * Add the admins and logs sections to the privileges
+     */
+    rows.push({
+        adminId: '1',
+        sectionName: 'admins',
+        operations: 'CUD',
+        publisher: '1',
+    });
+    rows.push({
+        adminId: '1',
+        sectionName: 'log',
+        operations: 'CUD',
+        publisher: '1',
+    });
+    await db
+        .insert(AdminPrivilegesTable)
+        .values(rows)
+        .onDuplicateKeyUpdate({
+        set: {
+            operations: 'CUD',
+            publisher: true,
+        },
+    });
+    return;
+}

package/dist/cli/lib/set-master-admin.d.ts

@@ -0,0 +1,2 @@
+export declare function setMasterAdmin(): Promise<void>;
+//# sourceMappingURL=set-master-admin.d.ts.map

package/dist/cli/lib/set-master-admin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-master-admin.d.ts","sourceRoot":"","sources":["../../../src/cli/lib/set-master-admin.ts"],"names":[],"mappings":"AAGA,wBAAsB,cAAc,kBA+FnC"}