nextjs-cms-kit 0.5.1

package/dist/lib/add-table-keys.js

@@ -0,0 +1,168 @@
+import chalk from 'chalk';
+import { db } from 'nextjs-cms/db/client';
+export async function addTableKeys(table, existingKeys) {
+    // console.log(chalk.gray(`  - Checking table keys`))
+    /**
+     * Number of SQL errors
+     */
+    let sqlErrors = 0;
+    /**
+     * Add the primary key, but first, check if the primary key exists or has changed
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (table.primaryKey) {
+        if (existingKeys) {
+            const { primaryKeys } = existingKeys;
+            /**
+             * Check if the existing primary key matches the new primary key
+             */
+            const primaryKeyChanged = primaryKeys.length !== table.primaryKey.length ||
+                !table.primaryKey.every((key) => primaryKeys.includes(key.name));
+            /**
+             * If primary key doesn't exist or has changed, update it
+             */
+            if (primaryKeys.length === 0 || primaryKeyChanged) {
+                /**
+                 * Drop existing primary key if it exists
+                 */
+                if (primaryKeys.length > 0) {
+                    console.log(chalk.gray(`  - Dropping existing primary key from '${table.name}: [${primaryKeys.join(', ')}]`));
+                    try {
+                        await db.execute(`ALTER TABLE \`${table.name}\` DROP PRIMARY KEY`);
+                    }
+                    catch (error) {
+                        sqlErrors++;
+                        console.error(chalk.red(`  - Error dropping primary key for table '${table.name}':`, error));
+                    }
+                }
+                /**
+                 * Add the new primary key
+                 */
+                console.log(chalk.gray(`  - Adding primary key to '${table.name}': [${table.primaryKey.map((key) => key.name).join(', ')}]`));
+                try {
+                    const primaryKeyColumns = table.primaryKey.map((column) => `\`${column.name}\``).join(', ');
+                    await db.execute(`ALTER TABLE \`${table.name}\` ADD PRIMARY KEY (${primaryKeyColumns})`);
+                }
+                catch (error) {
+                    sqlErrors++;
+                    console.error(chalk.red(`  - Error updating primary key for table '${table.name}':`, error));
+                    /**
+                     * Reverting to the old primary key
+                     */
+                    console.log(chalk.gray(`  - Re-adding old primary key to '${table.name}': [${primaryKeys.map((key) => key).join(', ')}]`));
+                    try {
+                        const primaryKeyColumns = primaryKeys.map((column) => `\`${column}\``).join(', ');
+                        await db.execute(`ALTER TABLE \`${table.name}\` ADD PRIMARY KEY (${primaryKeyColumns})`);
+                    }
+                    catch (error) {
+                        sqlErrors++;
+                        console.error(chalk.red(`  - Error re-adding primary key for table '${table.name}':`, error));
+                    }
+                }
+            }
+        }
+        else {
+            // TODO: What is this?
+            sqlErrors++;
+        }
+    }
+    /**
+     * Modify unique keys
+     */
+    if (table.unique) {
+        const existingUniqueKeys = existingKeys?.uniqueKeys ?? [];
+        for (const requestedUnique of table.unique) {
+            /**
+             * Check if the unique key already exists
+             */
+            const matchingUnique = existingUniqueKeys.find((u) => {
+                return (requestedUnique.columns.length === u.columns.length &&
+                    requestedUnique.columns.every((col) => u.columns.includes(col.name)));
+            });
+            const uniqueColumns = requestedUnique.columns.map((col) => `\`${col.name}\``).join(', ');
+            /**
+             * If key doesn't exist, add it
+             */
+            if (!matchingUnique) {
+                console.log(chalk.gray(`  - Adding unique key with columns [${requestedUnique.columns.map((col) => col.name).join(', ')}] to '${table.name}'`));
+                await db.execute(`ALTER TABLE \`${table.name}\` ADD UNIQUE ${requestedUnique.name ?? ''}(${uniqueColumns})`);
+            }
+        }
+        /**
+         * Drop any existing unique keys that are not in the new set (based on columns)
+         */
+        for (const existingUnique of existingUniqueKeys) {
+            if (!table.unique.find((unique) => {
+                return (unique.columns.length === existingUnique.columns.length &&
+                    unique.columns.every((col) => existingUnique.columns.includes(col.name)));
+            })) {
+                console.log(chalk.gray(`  - Dropping unique key with columns [${existingUnique.columns.join(', ')}] from '${table.name}'`));
+                await db.execute(`ALTER TABLE \`${table.name}\` DROP INDEX \`${existingUnique.name}\``);
+            }
+        }
+    }
+    /**
+     * Modify indexes
+     */
+    if (table.index) {
+        const existingIndexes = existingKeys?.indexKeys ?? [];
+        for (const index of table.index) {
+            const matchingIndex = existingIndexes.find((i) => {
+                return (index.columns.length === i.columns.length &&
+                    index.columns.every((col) => i.columns.includes(col.name)));
+            });
+            const indexColumns = index.columns.map((col) => `\`${col.name}\``).join(', ');
+            if (!matchingIndex) {
+                // Add index
+                console.log(chalk.gray(`  - Adding index with columns [${index.columns.map((col) => col.name).join(', ')}] to '${table.name}'`));
+                await db.execute(`ALTER TABLE \`${table.name}\` ADD INDEX ${index.name ?? ''}(${indexColumns})`);
+            }
+        }
+        /**
+         * Drop any existing indexes that are not in the new set (based on columns)
+         */
+        for (const existingIndex of existingIndexes) {
+            if (!table.index.find((index) => {
+                return (index.columns.length === existingIndex.columns.length &&
+                    index.columns.every((col) => existingIndex.columns.includes(col.name)));
+            })) {
+                console.log(chalk.gray(`  - Dropping index with columns [${existingIndex.columns.join(', ')}] from '${table.name}'`));
+                await db.execute(`ALTER TABLE \`${table.name}\` DROP INDEX \`${existingIndex.name}\``);
+            }
+        }
+    }
+    /**
+     * Modify fulltext indexes
+     */
+    if (table.fulltext) {
+        const existingIndexes = existingKeys?.fullTextKeys ?? [];
+        for (const requestedFullTextIndex of table.fulltext) {
+            const matchingFulltext = existingIndexes.find((i) => {
+                return (requestedFullTextIndex.columns.length === i.columns.length &&
+                    requestedFullTextIndex.columns.every((col) => i.columns.includes(col.name)));
+            });
+            const fulltextColumns = requestedFullTextIndex.columns.map((col) => `\`${col.name}\``).join(', ');
+            /**
+             * If fulltext index doesn't exist, add it
+             */
+            if (!matchingFulltext) {
+                // Add fulltext index
+                console.log(chalk.gray(`  - Adding fulltext index with columns [${requestedFullTextIndex.columns.map((col) => col.name).join(', ')}] to '${table.name}'`));
+                await db.execute(`ALTER TABLE \`${table.name}\` ADD FULLTEXT ${requestedFullTextIndex.name ?? ''}(${fulltextColumns})`);
+            }
+        }
+        /**
+         * Drop any existing fulltext indexes that are not in the new set (based on columns)
+         */
+        for (const existingFulltext of existingIndexes) {
+            if (!table.fulltext.find((fulltext) => {
+                return (fulltext.columns.length === existingFulltext.columns.length &&
+                    fulltext.columns.every((col) => existingFulltext.columns.includes(col.name)));
+            })) {
+                console.log(chalk.gray(`  - Dropping fulltext index with columns [${existingFulltext.columns.join(', ')}] from '${table.name}'`));
+                await db.execute(`ALTER TABLE \`${table.name}\` DROP INDEX \`${existingFulltext.name}\``);
+            }
+        }
+    }
+    return sqlErrors;
+}

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

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

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

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

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

@@ -0,0 +1,216 @@
+import { createConnection } from 'mysql2/promise';
+import { intro, isCancel, outro, text, spinner, note } from '@clack/prompts';
+import fs from 'fs';
+import path from 'path';
+import { cwd } from 'process';
+import { reloadAndUpdateEnvironmentVariables } from './reload-env';
+/**
+ * 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;
+    intro(`Welcome to LZCMS! Let's set up the database...`);
+    /**
+     * Step 1: Ask for connection credentials
+     */
+    note('Please provide your MySQL/MariaDB server credentials', 'Database Connection');
+    const dbHost = await text({
+        message: 'Database host:',
+        placeholder: 'localhost',
+        defaultValue: 'localhost',
+        validate(value) {
+            if (value && value.length < 2)
+                return `Database host must be at least 2 characters`;
+        },
+    });
+    if (isCancel(dbHost)) {
+        outro(`LZCMS init cancelled by user.`);
+        return;
+    }
+    const dbPort = await 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`;
+            }
+        },
+    });
+    if (isCancel(dbPort)) {
+        outro(`LZCMS init cancelled by user.`);
+        return;
+    }
+    const dbUser = await text({
+        message: 'Database username:',
+        validate(value) {
+            if (value.length < 1)
+                return `Database username is required`;
+        },
+    });
+    if (isCancel(dbUser)) {
+        outro(`LZCMS init cancelled by user.`);
+        return;
+    }
+    const dbPassword = await text({
+        message: 'Database password:',
+        validate(value) {
+            if (value.length < 1)
+                return `Database password is required`;
+        },
+    });
+    if (isCancel(dbPassword)) {
+        outro(`LZCMS init cancelled by user.`);
+        return;
+    }
+    /**
+     * Step 2: Test the database connection
+     */
+    const s = spinner();
+    let migrationClient;
+    try {
+        s.start('Testing database connection...');
+        /**
+         * 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('✓ Connected successfully!');
+        /**
+         * Step 3: Now that connection is successful, ask for database name
+         */
+        note('If the database does not exist, it will be created', 'Database Name');
+        const dbName = await text({
+            message: 'Database name:',
+            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 (isCancel(dbName)) {
+            outro(`LZCMS init cancelled by user.`);
+            return;
+        }
+        /**
+         * 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('✓ Database created successfully!');
+        /**
+         * Let's save the database credentials in the .env file
+         */
+        const envPath = path.resolve(cwd(), dev ? '.env.development' : '.env.production');
+        /**
+         * 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 reloadSuccess = reloadAndUpdateEnvironmentVariables(dbVariables, dev ? '.env.development' : '.env.production');
+        if (reloadSuccess) {
+            console.log('✓ Environment variables reloaded successfully!');
+        }
+        else {
+            console.warn('⚠️ Environment variables written to file but could not be reloaded in current process');
+        }
+        outro(`✓ Database setup completed successfully! Please run 'npm run lz:setup' to finish the setup.`);
+    }
+    catch (error) {
+        s.stop('✗ 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);
+        }
+        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/lib/fix-master-admin.d.ts

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

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

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

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

@@ -0,0 +1,7 @@
+import { intro, outro } from '@clack/prompts';
+import { fixMasterAdminPrivileges } from './actions';
+export async function fixMasterAdmin() {
+    intro(`Looking up sections...`);
+    await fixMasterAdminPrivileges();
+    outro(`Master admin privileges fixed`);
+}

package/dist/lib/reload-env.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Reloads environment variables from .env files
+ * This is useful after programmatically writing to .env files
+ */
+export declare function reloadEnvironmentVariables(envFile?: string): boolean;
+/**
+ * Updates specific environment variables in process.env
+ * This provides immediate availability without requiring a full reload
+ */
+export declare function updateEnvironmentVariables(variables: Record<string, string>): void;
+/**
+ * Reloads environment variables and updates specific ones in process.env
+ * This combines both approaches for maximum compatibility
+ */
+export declare function reloadAndUpdateEnvironmentVariables(variables?: Record<string, string>, envFile?: string): boolean;
+//# sourceMappingURL=reload-env.d.ts.map

package/dist/lib/reload-env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reload-env.d.ts","sourceRoot":"","sources":["../../src/lib/reload-env.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAepE;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAIlF;AAED;;;GAGG;AACH,wBAAgB,mCAAmC,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAQjH"}

package/dist/lib/reload-env.js

@@ -0,0 +1,42 @@
+import { config } from 'dotenv';
+import { cwd } from 'process';
+import path from 'path';
+/**
+ * Reloads environment variables from .env files
+ * This is useful after programmatically writing to .env files
+ */
+export function reloadEnvironmentVariables(envFile) {
+    try {
+        const envPath = envFile ? path.resolve(cwd(), envFile) : undefined;
+        const result = config({ path: envPath });
+        if (result.error) {
+            console.warn('⚠️ Error loading .env file:', result.error);
+            return false;
+        }
+        return true;
+    }
+    catch (error) {
+        console.warn('⚠️ Could not reload environment variables:', error);
+        return false;
+    }
+}
+/**
+ * Updates specific environment variables in process.env
+ * This provides immediate availability without requiring a full reload
+ */
+export function updateEnvironmentVariables(variables) {
+    Object.entries(variables).forEach(([key, value]) => {
+        process.env[key] = value;
+    });
+}
+/**
+ * Reloads environment variables and updates specific ones in process.env
+ * This combines both approaches for maximum compatibility
+ */
+export function reloadAndUpdateEnvironmentVariables(variables, envFile) {
+    const reloadSuccess = reloadEnvironmentVariables(envFile);
+    if (variables) {
+        updateEnvironmentVariables(variables);
+    }
+    return reloadSuccess;
+}

package/dist/lib/schema-generator.d.ts

@@ -0,0 +1,10 @@
+import type { FieldConfig } from 'nextjs-cms/core/fields';
+export declare function generateDrizzleSchema(table: {
+    name: string;
+    fields: FieldConfig[];
+    identifier: FieldConfig;
+}): {
+    schema: string;
+    columnTypes: string[];
+};
+//# sourceMappingURL=schema-generator.d.ts.map

package/dist/lib/schema-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-generator.d.ts","sourceRoot":"","sources":["../../src/lib/schema-generator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAqBzD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,WAAW,EAAE,CAAC;IAAC,UAAU,EAAE,WAAW,CAAA;CAAE,GAAG;IAC5G,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,MAAM,EAAE,CAAA;CACxB,CAiKA"}

package/dist/lib/schema-generator.js

@@ -0,0 +1,168 @@
+import { getCMSConfig } from 'nextjs-cms/core/config';
+// Converts snake_case to camelCase
+function toCamelCase(snake) {
+    return snake.toLowerCase().replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+// Converts snake_case to PascalCase
+function toPascalCase(snake) {
+    return snake.toLowerCase().replace(/(^|_)([a-z])/g, (_, __, letter) => letter.toUpperCase());
+}
+// Converts any case (camelCase, PascalCase, etc.) to snake_case
+function toSnakeCase(str) {
+    return str
+        .replace(/([A-Z])/g, '_$1') // Add underscore before capital letters
+        .replace(/^_/, '') // Remove leading underscore if any
+        .toLowerCase();
+}
+export function generateDrizzleSchema(table) {
+    let tableCaseStyleFn;
+    let columnCaseStyleFn;
+    const lzConfig = getCMSConfig();
+    switch (lzConfig.db.schemaNamingConvention.tableCaseStyle) {
+        case 'snakeCase':
+            tableCaseStyleFn = toSnakeCase;
+            break;
+        case 'camelCase':
+            tableCaseStyleFn = toCamelCase;
+            break;
+        case 'pascalCase':
+        default:
+            tableCaseStyleFn = toPascalCase;
+            break;
+    }
+    switch (lzConfig.db.schemaNamingConvention.columnCaseStyle) {
+        case 'snakeCase':
+            columnCaseStyleFn = toSnakeCase;
+            break;
+        case 'pascalCase':
+            columnCaseStyleFn = toPascalCase;
+            break;
+        case 'camelCase':
+        default:
+            columnCaseStyleFn = toCamelCase;
+            break;
+    }
+    /**
+     * This function generates a Drizzle schema for a given table.
+     * It takes a table object with a name, inputs (fields), and an identifier field.
+     * It returns an object containing the generated schema as a string and an array of column types.
+     */
+    const drizzleColumnTypes = [];
+    let schema = '';
+    const schemaName = tableCaseStyleFn(`${table.name}_table`);
+    schema += `export const ${schemaName} = mysqlTable('${table.name}', {\n`;
+    for (const input of table.fields) {
+        let columnType;
+        let drizzleColumnType;
+        // let columnOptions = ''
+        switch (input.type) {
+            case 'text':
+                columnType = `varchar('${input.name}', { length: ${input.maxLength ?? 255} })`;
+                drizzleColumnType = 'varchar';
+                break;
+            case 'textarea':
+            case 'rich_text':
+                columnType = `longtext('${input.name}')`;
+                drizzleColumnType = 'longtext';
+                break;
+            case 'select_multiple':
+            case 'password':
+                columnType = `varchar('${input.name}', { length: 255 })`;
+                drizzleColumnType = 'varchar';
+                break;
+            case 'select':
+                if (input.optionsType === 'static' && input.options) {
+                    columnType = `mysqlEnum('${input.name}', [${input.options.map((option) => `'${option.value}'`).join(', ')}])`;
+                    drizzleColumnType = 'mysqlEnum';
+                }
+                else {
+                    columnType = `varchar('${input.name}', { length: 255 })`;
+                    drizzleColumnType = 'varchar';
+                }
+                break;
+            case 'checkbox':
+                columnType = `boolean('${input.name}')`;
+                drizzleColumnType = 'boolean';
+                break;
+            case 'color':
+                columnType = `varchar('${input.name}', { length: 7 })`; // #RRGGBB
+                drizzleColumnType = 'varchar';
+                break;
+            case 'date':
+                switch (input.format) {
+                    case 'timestamp':
+                        columnType = `timestamp('${input.name}')`;
+                        drizzleColumnType = 'timestamp';
+                        break;
+                    case 'date':
+                        columnType = `date('${input.name}')`;
+                        drizzleColumnType = 'date';
+                        break;
+                    case 'datetime':
+                        columnType = `datetime('${input.name}')`;
+                        drizzleColumnType = 'datetime';
+                        break;
+                }
+                break;
+            case 'number':
+                switch (input.format) {
+                    case 'double':
+                        columnType = `double('${input.name}')`;
+                        drizzleColumnType = 'double';
+                        break;
+                    case 'float':
+                        columnType = `float('${input.name}')`;
+                        drizzleColumnType = 'float';
+                        break;
+                    case 'int':
+                    default:
+                        columnType = `int('${input.name}')`;
+                        drizzleColumnType = 'int';
+                        if (input.hasAutoIncrement) {
+                            columnType += `.autoincrement()`;
+                        }
+                        break;
+                }
+                break;
+            case 'map':
+            case 'tags':
+            case 'photo':
+            case 'video':
+            case 'document':
+                columnType = `varchar('${input.name}', { length: 255 })`; // TEXT type
+                drizzleColumnType = 'varchar';
+                break;
+            default:
+                // @ts-expect-error name will be any at this point
+                // TODO: Should I throw an error instead?
+                columnType = `varchar('${input.name}', { length: 255 })`;
+                drizzleColumnType = 'varchar';
+                break;
+        }
+        if (input.required) {
+            columnType += `.notNull()`;
+        }
+        if (input === table.identifier) {
+            columnType += `.primaryKey()`;
+        }
+        /*if (input.type === 'date') {
+            columnType += `.defaultNow()`
+        }*/
+        schema += `    ${columnCaseStyleFn(input.name)}: ${columnType},\n`;
+        /**
+         * First, let's check if the column type is already in the drizzleColumnTypes array
+         */
+        if (drizzleColumnType && !drizzleColumnTypes.includes(drizzleColumnType)) {
+            /**
+             * If it's not, add it to the array
+             */
+            drizzleColumnTypes.push(drizzleColumnType);
+        }
+    }
+    schema = schema.slice(0, -2); // Remove the last comma and newline
+    schema += `\n});\n\n`;
+    return {
+        schema: schema,
+        columnTypes: drizzleColumnTypes,
+    };
+}

package/dist/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/lib/set-master-admin.d.ts.map

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