@pgpmjs/core 3.0.0

package/esm/utils/debug.js

@@ -0,0 +1,147 @@
+import { Logger } from '@pgpmjs/logger';
+const log = new Logger('debug');
+export class DebugHelper {
+    options;
+    constructor(options = { enabled: false }) {
+        this.options = {
+            logLevel: 'debug',
+            showStackTrace: true,
+            showQueryParams: true,
+            showFullSQL: true,
+            ...options
+        };
+    }
+    isEnabled() {
+        return this.options.enabled;
+    }
+    logError(message, error, context) {
+        if (!this.options.enabled)
+            return;
+        log.error(message);
+        if (context) {
+            log.error('Context:', JSON.stringify(context, null, 2));
+        }
+        if (error) {
+            log.error('Error Details:', {
+                code: error.code,
+                message: error.message,
+                severity: error.severity,
+                detail: error.detail,
+                hint: error.hint,
+                position: error.position,
+                where: error.where,
+                schema: error.schema,
+                table: error.table,
+                column: error.column,
+                dataType: error.dataType,
+                constraint: error.constraint,
+                file: error.file,
+                line: error.line,
+                routine: error.routine
+            });
+            if (this.options.showStackTrace && error.stack) {
+                log.error('Stack Trace:', error.stack);
+            }
+        }
+    }
+    logQuery(query, params, duration) {
+        if (!this.options.enabled)
+            return;
+        log.debug(`Query executed in ${duration || 0}ms:`);
+        if (this.options.showFullSQL) {
+            log.debug('Full SQL:', query);
+        }
+        else {
+            log.debug('SQL Preview:', query.split('\n')[0].trim());
+        }
+        if (this.options.showQueryParams && params && params.length > 0) {
+            log.debug('Parameters:', JSON.stringify(params, null, 2));
+        }
+    }
+    logTransactionStart() {
+        if (!this.options.enabled)
+            return;
+        log.debug('🔄 Transaction started');
+    }
+    logTransactionCommit(duration) {
+        if (!this.options.enabled)
+            return;
+        log.debug(`✅ Transaction committed in ${duration || 0}ms`);
+    }
+    logTransactionRollback(duration) {
+        if (!this.options.enabled)
+            return;
+        log.debug(`❌ Transaction rolled back after ${duration || 0}ms`);
+    }
+    static fromEnvironment() {
+        const enabled = process.env.LAUNCHQL_DEBUG === 'true' || process.env.DEBUG === 'launchql*';
+        const logLevel = process.env.LAUNCHQL_DEBUG_LEVEL || 'debug';
+        const showStackTrace = process.env.LAUNCHQL_DEBUG_STACK !== 'false';
+        const showQueryParams = process.env.LAUNCHQL_DEBUG_PARAMS !== 'false';
+        const showFullSQL = process.env.LAUNCHQL_DEBUG_SQL !== 'false';
+        return new DebugHelper({
+            enabled,
+            logLevel,
+            showStackTrace,
+            showQueryParams,
+            showFullSQL
+        });
+    }
+}
+// Global debug instance
+export const debugHelper = DebugHelper.fromEnvironment();
+// Utility functions
+export function enableDebugMode() {
+    process.env.LAUNCHQL_DEBUG = 'true';
+    process.env.LOG_LEVEL = 'debug';
+    log.info('🔍 Debug mode enabled');
+    log.info('   Set LAUNCHQL_DEBUG=false to disable');
+    log.info('   Set LAUNCHQL_DEBUG_LEVEL=info|warn|error|debug to change log level');
+    log.info('   Set LAUNCHQL_DEBUG_STACK=false to hide stack traces');
+    log.info('   Set LAUNCHQL_DEBUG_PARAMS=false to hide query parameters');
+    log.info('   Set LAUNCHQL_DEBUG_SQL=false to hide full SQL scripts');
+}
+export function createDebugSummary(error, context) {
+    const summary = [];
+    summary.push('=== LaunchQL Debug Summary ===');
+    summary.push('');
+    if (error) {
+        summary.push('Error Information:');
+        summary.push(`  Code: ${error.code || 'N/A'}`);
+        summary.push(`  Message: ${error.message || 'N/A'}`);
+        summary.push(`  Severity: ${error.severity || 'N/A'}`);
+        if (error.detail)
+            summary.push(`  Detail: ${error.detail}`);
+        if (error.hint)
+            summary.push(`  Hint: ${error.hint}`);
+        if (error.position)
+            summary.push(`  Position: ${error.position}`);
+        if (error.where)
+            summary.push(`  Where: ${error.where}`);
+        if (error.schema)
+            summary.push(`  Schema: ${error.schema}`);
+        if (error.table)
+            summary.push(`  Table: ${error.table}`);
+        if (error.column)
+            summary.push(`  Column: ${error.column}`);
+        if (error.constraint)
+            summary.push(`  Constraint: ${error.constraint}`);
+        summary.push('');
+    }
+    if (context) {
+        summary.push('Context:');
+        Object.entries(context).forEach(([key, value]) => {
+            summary.push(`  ${key}: ${JSON.stringify(value)}`);
+        });
+        summary.push('');
+    }
+    summary.push('Debugging Tips:');
+    summary.push('  1. Run with LAUNCHQL_DEBUG=true for more details');
+    summary.push('  2. Check the transaction query history above');
+    summary.push('  3. Verify your SQL scripts for syntax errors');
+    summary.push('  4. Ensure dependencies are applied in correct order');
+    summary.push('  5. Check database permissions and schema existence');
+    summary.push('');
+    summary.push('=== End Debug Summary ===');
+    return summary.join('\n');
+}

package/esm/utils/target-utils.js

@@ -0,0 +1,37 @@
+import { errors } from '@pgpmjs/types';
+export function parseTarget(target) {
+    if (!target) {
+        throw new Error('Target parameter is required');
+    }
+    if (target.includes(':@')) {
+        const atIndex = target.indexOf(':@');
+        const beforeAt = target.substring(0, atIndex);
+        const afterAt = target.substring(atIndex + 2);
+        if (!afterAt) {
+            throw errors.INVALID_NAME({ name: target, type: 'tag', rules: 'Expected format: package:@tagName' });
+        }
+        // Check if this is a simple package:@tag format
+        if (!beforeAt.includes(':')) {
+            if (!beforeAt) {
+                throw errors.INVALID_NAME({ name: target, type: 'tag', rules: 'Expected format: package:@tagName' });
+            }
+            return { packageName: beforeAt, toChange: `@${afterAt}` };
+        }
+        throw errors.INVALID_NAME({ name: target, type: 'change', rules: 'Expected formats: package, package:changeName, or package:@tagName' });
+    }
+    if (target.includes(':') && !target.includes('@')) {
+        const parts = target.split(':');
+        if (parts.length > 2) {
+            throw errors.INVALID_NAME({ name: target, type: 'change', rules: 'Expected formats: package, package:changeName, or package:@tagName' });
+        }
+        const [packageName, changeName] = parts;
+        if (!packageName || !changeName) {
+            throw errors.INVALID_NAME({ name: target, type: 'change', rules: 'Expected format: package:changeName' });
+        }
+        return { packageName, toChange: changeName };
+    }
+    if (!target.includes(':')) {
+        return { packageName: target, toChange: undefined };
+    }
+    throw errors.INVALID_NAME({ name: target, type: 'change', rules: 'Expected formats: package, package:changeName, or package:@tagName' });
+}

package/esm/workspace/paths.js

@@ -0,0 +1,43 @@
+import { walkUp } from './utils';
+const PROJECT_FILES = {
+    PLAN: 'pgpm.plan',
+    LAUNCHQL: 'pgpm.json',
+};
+/**
+ * Finds the module path by looking for pgpm.plan.
+ * @param cwd - Current working directory.
+ * @returns A promise that resolves to the directory path containing `pgpm.plan`.
+ */
+export const modulePath = (cwd = process.cwd()) => {
+    return walkUp(cwd, PROJECT_FILES.PLAN);
+};
+/**
+ * Finds the LaunchQL project path.
+ * @param cwd - Current working directory.
+ * @returns A promise that resolves to the directory path containing `pgpm.json`.
+ */
+export const launchqlPath = (cwd = process.cwd()) => {
+    return walkUp(cwd, PROJECT_FILES.LAUNCHQL);
+};
+export const getWorkspacePath = (cwd) => {
+    let workspacePath;
+    try {
+        workspacePath = launchqlPath(cwd);
+    }
+    catch (err) {
+        console.error('Error: You must be in a LaunchQL workspace. You can initialize one with `lql init workspace` (or `pgpm init workspace`).');
+        process.exit(1);
+    }
+    return workspacePath;
+};
+export const getModulePath = (cwd) => {
+    let pkgPath;
+    try {
+        pkgPath = modulePath(cwd);
+    }
+    catch (err) {
+        console.error('Error: You must be in a LaunchQL module. You can initialize one with the `init` command.');
+        process.exit(1);
+    }
+    return pkgPath;
+};

package/esm/workspace/utils.js

@@ -0,0 +1,31 @@
+import { existsSync } from 'fs';
+import { dirname, resolve } from 'path';
+import { errors } from '@pgpmjs/types';
+/**
+ * Recursively walks up directories to find a specific file (sync version).
+ * @param startDir - Starting directory.
+ * @param filename - The target file to search for.
+ * @returns The directory path containing the file.
+ */
+export const walkUp = (startDir, filename) => {
+    let currentDir = resolve(startDir);
+    while (currentDir) {
+        const targetPath = resolve(currentDir, filename);
+        if (existsSync(targetPath)) {
+            return currentDir;
+        }
+        const parentDir = dirname(currentDir);
+        if (parentDir === currentDir) {
+            break;
+        }
+        currentDir = parentDir;
+    }
+    throw errors.FILE_NOT_FOUND({ filePath: filename, type: 'configuration' });
+};
+export const sluggify = (text) => {
+    return text.toString().toLowerCase().trim()
+        .replace(/\s+/g, '-') // Replace spaces with -
+        .replace(/&/g, '-and-') // Replace & with 'and'
+        .replace(/[^\w\-]+/g, '') // Remove all non-word chars
+        .replace(/\-\-+/g, '-'); // Replace multiple - with single -
+};

package/export/export-meta.d.ts

@@ -0,0 +1,8 @@
+import { PgpmOptions } from '@pgpmjs/types';
+interface ExportMetaParams {
+    opts: PgpmOptions;
+    dbname: string;
+    database_id: string;
+}
+export declare const exportMeta: ({ opts, dbname, database_id }: ExportMetaParams) => Promise<string>;
+export {};

package/export/export-meta.js

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportMeta = void 0;
+const csv_to_pg_1 = require("csv-to-pg");
+const pg_cache_1 = require("pg-cache");
+const config = {
+    database: {
+        schema: 'collections_public',
+        table: 'database',
+        fields: {
+            id: 'uuid',
+            owner_id: 'uuid',
+            name: 'text',
+            hash: 'uuid'
+        }
+    },
+    database_extension: {
+        schema: 'collections_public',
+        table: 'database_extensions',
+        fields: {
+            name: 'text',
+            database_id: 'uuid'
+        }
+    },
+    schema: {
+        schema: 'collections_public',
+        table: 'schema',
+        fields: {
+            id: 'uuid',
+            database_id: 'uuid',
+            name: 'text',
+            schema_name: 'text',
+            description: 'text'
+        }
+    },
+    table: {
+        schema: 'collections_public',
+        table: 'table',
+        fields: {
+            id: 'uuid',
+            database_id: 'uuid',
+            schema_id: 'uuid',
+            name: 'text',
+            description: 'text'
+        }
+    },
+    field: {
+        schema: 'collections_public',
+        table: 'field',
+        fields: {
+            id: 'uuid',
+            database_id: 'uuid',
+            table_id: 'uuid',
+            name: 'text',
+            type: 'text',
+            description: 'text'
+        }
+    },
+    domains: {
+        schema: 'meta_public',
+        table: 'domains',
+        fields: {
+            id: 'uuid',
+            database_id: 'uuid',
+            site_id: 'uuid',
+            api_id: 'uuid',
+            domain: 'text',
+            subdomain: 'text'
+        }
+    },
+    sites: {
+        schema: 'meta_public',
+        table: 'sites',
+        fields: {
+            id: 'uuid',
+            database_id: 'uuid',
+            title: 'text',
+            description: 'text',
+            og_image: 'image',
+            favicon: 'upload',
+            apple_touch_icon: 'image',
+            logo: 'image',
+            dbname: 'text'
+        }
+    },
+    apis: {
+        schema: 'meta_public',
+        table: 'apis',
+        fields: {
+            id: 'uuid',
+            database_id: 'uuid',
+            name: 'text',
+            dbname: 'text',
+            is_public: 'boolean',
+            role_name: 'text',
+            anon_role: 'text'
+        }
+    },
+    apps: {
+        schema: 'meta_public',
+        table: 'apps',
+        fields: {
+            id: 'uuid',
+            database_id: 'uuid',
+            site_id: 'uuid',
+            name: 'text',
+            app_image: 'image',
+            app_store_link: 'url',
+            app_store_id: 'text',
+            app_id_prefix: 'text',
+            play_store_link: 'url'
+        }
+    },
+    site_modules: {
+        schema: 'meta_public',
+        table: 'site_modules',
+        fields: {
+            id: 'uuid',
+            database_id: 'uuid',
+            site_id: 'uuid',
+            name: 'text',
+            data: 'jsonb'
+        }
+    },
+    site_themes: {
+        schema: 'meta_public',
+        table: 'site_themes',
+        fields: {
+            id: 'uuid',
+            database_id: 'uuid',
+            site_id: 'uuid',
+            theme: 'jsonb'
+        }
+    },
+    api_modules: {
+        schema: 'meta_public',
+        table: 'api_modules',
+        fields: {
+            id: 'uuid',
+            database_id: 'uuid',
+            api_id: 'uuid',
+            name: 'text',
+            data: 'jsonb'
+        }
+    },
+    api_extensions: {
+        schema: 'meta_public',
+        table: 'api_extensions',
+        fields: {
+            id: 'uuid',
+            database_id: 'uuid',
+            api_id: 'uuid',
+            schema_name: 'text'
+        }
+    },
+    api_schemata: {
+        schema: 'meta_public',
+        table: 'api_schemata',
+        fields: {
+            id: 'uuid',
+            database_id: 'uuid',
+            schema_id: 'uuid',
+            api_id: 'uuid'
+        }
+    },
+    rls_module: {
+        schema: 'meta_public',
+        table: 'rls_module',
+        fields: {
+            id: 'uuid',
+            database_id: 'uuid',
+            api_id: 'uuid',
+            schema_id: 'uuid',
+            private_schema_id: 'uuid',
+            tokens_table_id: 'uuid',
+            users_table_id: 'uuid',
+            authenticate: 'text',
+            authenticate_strict: 'text',
+            current_role: 'text',
+            current_role_id: 'text'
+        }
+    },
+    user_auth_module: {
+        schema: 'meta_public',
+        table: 'user_auth_module',
+        fields: {
+            id: 'uuid',
+            database_id: 'uuid',
+            schema_id: 'uuid',
+            emails_table_id: 'uuid',
+            users_table_id: 'uuid',
+            secrets_table_id: 'uuid',
+            encrypted_table_id: 'uuid',
+            tokens_table_id: 'uuid',
+            sign_in_function: 'text',
+            sign_up_function: 'text',
+            sign_out_function: 'text',
+            sign_in_one_time_token_function: 'text',
+            one_time_token_function: 'text',
+            extend_token_expires: 'text',
+            send_account_deletion_email_function: 'text',
+            delete_account_function: 'text',
+            set_password_function: 'text',
+            reset_password_function: 'text',
+            forgot_password_function: 'text',
+            send_verification_email_function: 'text',
+            verify_email_function: 'text'
+        }
+    }
+};
+const exportMeta = async ({ opts, dbname, database_id }) => {
+    const pool = (0, pg_cache_1.getPgPool)({
+        ...opts.pg,
+        database: dbname
+    });
+    const sql = {};
+    const parsers = Object.entries(config).reduce((m, [name, config]) => {
+        m[name] = new csv_to_pg_1.Parser(config);
+        return m;
+    }, {});
+    const queryAndParse = async (key, query) => {
+        const result = await pool.query(query, [database_id]);
+        if (result.rows.length) {
+            sql[key] = await parsers[key].parse(result.rows);
+        }
+    };
+    await queryAndParse('database', `SELECT * FROM collections_public.database WHERE id = $1`);
+    await queryAndParse('schema', `SELECT * FROM collections_public.schema WHERE database_id = $1`);
+    await queryAndParse('table', `SELECT * FROM collections_public.table WHERE database_id = $1`);
+    await queryAndParse('domains', `SELECT * FROM meta_public.domains WHERE database_id = $1`);
+    await queryAndParse('apis', `SELECT * FROM meta_public.apis WHERE database_id = $1`);
+    await queryAndParse('sites', `SELECT * FROM meta_public.sites WHERE database_id = $1`);
+    await queryAndParse('api_modules', `SELECT * FROM meta_public.api_modules WHERE database_id = $1`);
+    await queryAndParse('site_modules', `SELECT * FROM meta_public.site_modules WHERE database_id = $1`);
+    await queryAndParse('site_themes', `SELECT * FROM meta_public.site_themes WHERE database_id = $1`);
+    await queryAndParse('apps', `SELECT * FROM meta_public.apps WHERE database_id = $1`);
+    await queryAndParse('database_extension', `SELECT * FROM collections_public.database_extension WHERE database_id = $1`);
+    await queryAndParse('api_extensions', `SELECT * FROM meta_public.api_extensions WHERE database_id = $1`);
+    await queryAndParse('api_schemata', `SELECT * FROM meta_public.api_schemata WHERE database_id = $1`);
+    await queryAndParse('rls_module', `SELECT * FROM meta_public.rls_module WHERE database_id = $1`);
+    await queryAndParse('user_auth_module', `SELECT * FROM meta_public.user_auth_module WHERE database_id = $1`);
+    return Object.entries(sql).reduce((m, [_, v]) => m + '\n\n' + v, '');
+};
+exports.exportMeta = exportMeta;

package/export/export-migrations.d.ts

@@ -0,0 +1,17 @@
+import { PgpmOptions } from '@pgpmjs/types';
+import { PgpmPackage } from '../core/class/pgpm';
+interface ExportOptions {
+    project: PgpmPackage;
+    options: PgpmOptions;
+    dbInfo: {
+        dbname: string;
+        database_ids: string[];
+    };
+    author: string;
+    outdir: string;
+    schema_names: string[];
+    extensionName?: string;
+    metaExtensionName: string;
+}
+export declare const exportMigrations: ({ project, options, dbInfo, author, outdir, schema_names, extensionName, metaExtensionName }: ExportOptions) => Promise<void>;
+export {};