@pgpmjs/core 3.0.0

package/export/export-migrations.js

@@ -0,0 +1,187 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportMigrations = void 0;
+const fs_1 = require("fs");
+const glob_1 = require("glob");
+const komoji_1 = require("komoji");
+const path_1 = __importDefault(require("path"));
+const pg_cache_1 = require("pg-cache");
+const files_1 = require("../files");
+const export_meta_1 = require("./export-meta");
+const exportMigrationsToDisk = async ({ project, options, database, databaseId, author, outdir, schema_names, extensionName, metaExtensionName }) => {
+    outdir = outdir + '/';
+    const pgPool = (0, pg_cache_1.getPgPool)({
+        ...options.pg,
+        database
+    });
+    const db = await pgPool.query(`select * from collections_public.database where id=$1`, [databaseId]);
+    const schemas = await pgPool.query(`select * from collections_public.schema where database_id=$1`, [databaseId]);
+    if (!db?.rows?.length) {
+        console.log('NO DATABASES.');
+        return;
+    }
+    if (!schemas?.rows?.length) {
+        console.log('NO SCHEMAS.');
+        return;
+    }
+    const name = extensionName || db.rows[0].name;
+    const { replace, replacer } = makeReplacer({
+        schemas: schemas.rows.filter((schema) => schema_names.includes(schema.schema_name)),
+        name
+    });
+    const results = await pgPool.query(`select * from db_migrate.sql_actions order by id`);
+    const opts = {
+        name,
+        replacer,
+        outdir,
+        author
+    };
+    if (results?.rows?.length > 0) {
+        await preparePackage({
+            project,
+            author,
+            outdir,
+            name,
+            extensions: [
+                'plpgsql',
+                'uuid-ossp',
+                'citext',
+                'pgcrypto',
+                'btree_gist',
+                'postgis',
+                'hstore',
+                'db-meta-schema',
+                'launchql-inflection',
+                'launchql-uuid',
+                'launchql-utils',
+                'launchql-database-jobs',
+                'launchql-jwt-claims',
+                'launchql-stamps',
+                'launchql-base32',
+                'launchql-totp',
+                'launchql-types',
+                'launchql-default-roles'
+            ]
+        });
+        (0, files_1.writeSqitchPlan)(results.rows, opts);
+        (0, files_1.writeSqitchFiles)(results.rows, opts);
+        let meta = await (0, export_meta_1.exportMeta)({
+            opts: options,
+            dbname: database,
+            database_id: databaseId
+        });
+        meta = replacer(meta);
+        await preparePackage({
+            project,
+            author,
+            outdir,
+            extensions: ['plpgsql', 'db-meta-schema', 'db-meta-modules'],
+            name: metaExtensionName
+        });
+        const metaReplacer = makeReplacer({
+            schemas: schemas.rows.filter((schema) => schema_names.includes(schema.schema_name)),
+            name: metaExtensionName
+        });
+        const metaPackage = [
+            {
+                deps: [],
+                deploy: 'migrate/meta',
+                content: `SET session_replication_role TO replica;
+-- using replica in case we are deploying triggers to collections_public
+
+-- unaccent, postgis affected and require grants
+GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA public to public;
+
+DO $LQLMIGRATION$
+  DECLARE
+  BEGIN
+  
+    EXECUTE format('GRANT CONNECT ON DATABASE %I TO %I', current_database(), 'app_user');
+    EXECUTE format('GRANT CONNECT ON DATABASE %I TO %I', current_database(), 'app_admin');
+
+  END;
+$LQLMIGRATION$;
+
+${meta}
+
+UPDATE meta_public.apis
+      SET dbname = current_database() WHERE TRUE;
+
+UPDATE meta_public.sites
+      SET dbname = current_database() WHERE TRUE;
+
+SET session_replication_role TO DEFAULT;
+`
+            }
+        ];
+        opts.replacer = metaReplacer.replacer;
+        opts.name = metaExtensionName;
+        (0, files_1.writeSqitchPlan)(metaPackage, opts);
+        (0, files_1.writeSqitchFiles)(metaPackage, opts);
+    }
+    pgPool.end();
+};
+const exportMigrations = async ({ project, options, dbInfo, author, outdir, schema_names, extensionName, metaExtensionName }) => {
+    for (let v = 0; v < dbInfo.database_ids.length; v++) {
+        const databaseId = dbInfo.database_ids[v];
+        await exportMigrationsToDisk({
+            project,
+            options,
+            extensionName,
+            metaExtensionName,
+            database: dbInfo.dbname,
+            databaseId,
+            schema_names,
+            author,
+            outdir
+        });
+    }
+};
+exports.exportMigrations = exportMigrations;
+/**
+ * Creates a Sqitch package directory or resets the deploy/revert/verify directories if it exists.
+ */
+const preparePackage = async ({ project, author, outdir, name, extensions }) => {
+    const curDir = process.cwd();
+    const sqitchDir = path_1.default.resolve(path_1.default.join(outdir, name));
+    (0, fs_1.mkdirSync)(sqitchDir, { recursive: true });
+    process.chdir(sqitchDir);
+    const plan = (0, glob_1.sync)(path_1.default.join(sqitchDir, 'pgpm.plan'));
+    if (!plan.length) {
+        await project.initModule({
+            name,
+            description: name,
+            author,
+            extensions,
+        });
+    }
+    else {
+        (0, fs_1.rmSync)(path_1.default.resolve(sqitchDir, 'deploy'), { recursive: true, force: true });
+        (0, fs_1.rmSync)(path_1.default.resolve(sqitchDir, 'revert'), { recursive: true, force: true });
+        (0, fs_1.rmSync)(path_1.default.resolve(sqitchDir, 'verify'), { recursive: true, force: true });
+    }
+    process.chdir(curDir);
+};
+/**
+ * Generates a function for replacing schema names and extension names in strings.
+ */
+const makeReplacer = ({ schemas, name }) => {
+    const replacements = ['launchql-extension-name', name];
+    const schemaReplacers = schemas.map((schema) => [
+        schema.schema_name,
+        (0, komoji_1.toSnakeCase)(`${name}_${schema.name}`)
+    ]);
+    const replace = [...schemaReplacers, replacements].map(([from, to]) => [new RegExp(from, 'g'), to]);
+    const replacer = (str, n = 0) => {
+        if (!str)
+            return '';
+        if (replace[n] && replace[n].length === 2) {
+            return replacer(str.replace(replace[n][0], replace[n][1]), n + 1);
+        }
+        return str;
+    };
+    return { replacer, replace };
+};

package/extensions/extensions.d.ts

@@ -0,0 +1,5 @@
+import { ModuleMap } from '../modules/modules';
+/**
+ * Get the list of available extensions, including predefined core extensions.
+ */
+export declare const getAvailableExtensions: (modules: ModuleMap) => string[];

package/extensions/extensions.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAvailableExtensions = void 0;
+/**
+ * Get the list of available extensions, including predefined core extensions.
+ */
+const getAvailableExtensions = (modules) => {
+    const coreExtensions = [
+        'address_standardizer',
+        'address_standardizer_data_us',
+        'bloom',
+        'btree_gin',
+        'btree_gist',
+        'citext',
+        'hstore',
+        'intarray',
+        'pg_trgm',
+        'pgcrypto',
+        'plpgsql',
+        'plperl',
+        'plv8',
+        'postgis_tiger_geocoder',
+        'postgis_topology',
+        'postgis',
+        'postgres_fdw',
+        'unaccent',
+        'uuid-ossp',
+    ];
+    return Object.keys(modules).reduce((acc, module) => {
+        if (!acc.includes(module))
+            acc.push(module);
+        return acc;
+    }, [...coreExtensions]);
+};
+exports.getAvailableExtensions = getAvailableExtensions;

package/files/extension/index.d.ts

@@ -0,0 +1,2 @@
+export * from './reader';
+export * from './writer';

package/files/extension/index.js

@@ -0,0 +1,19 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Re-export all extension functionality
+__exportStar(require("./reader"), exports);
+__exportStar(require("./writer"), exports);

package/files/extension/reader.d.ts

@@ -0,0 +1,24 @@
+import { ExtensionInfo } from './writer';
+export interface Module {
+    path: string;
+    requires: string[];
+    version: string;
+}
+/**
+ * Parse a .control file and extract its metadata.
+ * https://www.postgresql.org/docs/current/extend-extensions.html
+ */
+export declare function parseControlFile(filePath: string, basePath: string): Module;
+/**
+ * Parse the pgpm.plan file to get the extension name.
+ */
+export declare const getExtensionName: (packageDir: string) => string;
+/**
+ * Get detailed information about an extension in the specified directory.
+ */
+export declare const getExtensionInfo: (packageDir: string) => ExtensionInfo;
+/**
+ * Get a list of extensions required by an extension from its control file.
+ * Returns an empty array if the file doesn't exist or has no requires line.
+ */
+export declare const getInstalledExtensions: (controlFilePath: string) => string[];

package/files/extension/reader.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInstalledExtensions = exports.getExtensionInfo = exports.getExtensionName = void 0;
+exports.parseControlFile = parseControlFile;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const plan_1 = require("../plan");
+/**
+ * Parse a .control file and extract its metadata.
+ * https://www.postgresql.org/docs/current/extend-extensions.html
+ */
+function parseControlFile(filePath, basePath) {
+    const contents = (0, fs_1.readFileSync)(filePath, 'utf-8');
+    const key = (0, path_1.basename)(filePath).split('.control')[0];
+    const requires = contents
+        .split('\n')
+        .find((line) => /^requires/.test(line))
+        ?.split('=')[1]
+        .split(',')
+        .map((req) => req.replace(/[\'\s]*/g, '').trim()) || [];
+    const version = contents
+        .split('\n')
+        .find((line) => /^default_version/.test(line))
+        ?.split('=')[1]
+        .replace(/[\']*/g, '')
+        .trim() || '';
+    return {
+        path: (0, path_1.dirname)((0, path_1.relative)(basePath, filePath)),
+        requires,
+        version,
+    };
+}
+/**
+ * Parse the pgpm.plan file to get the extension name.
+ */
+const getExtensionName = (packageDir) => {
+    const planPath = `${packageDir}/pgpm.plan`;
+    const plan = (0, plan_1.parsePlanFileSimple)(planPath);
+    if (!plan.package) {
+        throw new Error('No package name found in pgpm.plan!');
+    }
+    return plan.package;
+};
+exports.getExtensionName = getExtensionName;
+/**
+ * Get detailed information about an extension in the specified directory.
+ */
+const getExtensionInfo = (packageDir) => {
+    const pkgPath = `${packageDir}/package.json`;
+    const pkg = require(pkgPath);
+    const extname = (0, exports.getExtensionName)(packageDir);
+    const version = pkg.version;
+    const Makefile = `${packageDir}/Makefile`;
+    const controlFile = `${packageDir}/${extname}.control`;
+    const sqlFile = `sql/${extname}--${version}.sql`;
+    return { extname, packageDir, version, Makefile, controlFile, sqlFile };
+};
+exports.getExtensionInfo = getExtensionInfo;
+/**
+ * Get a list of extensions required by an extension from its control file.
+ * Returns an empty array if the file doesn't exist or has no requires line.
+ */
+const getInstalledExtensions = (controlFilePath) => {
+    try {
+        const contents = (0, fs_1.readFileSync)(controlFilePath, 'utf-8');
+        const match = contents.match(/^\s*requires\s*=\s*'([^']*)'/m);
+        if (!match) {
+            return [];
+        }
+        const requiresValue = match[1];
+        if (!requiresValue || requiresValue.trim() === '') {
+            return [];
+        }
+        return requiresValue
+            .split(',')
+            .map((ext) => ext.trim())
+            .filter((ext) => ext.length > 0);
+    }
+    catch (e) {
+        if (e.code === 'ENOENT') {
+            return [];
+        }
+        throw new Error(`Error reading control file at ${controlFilePath}: ${e.message}`);
+    }
+};
+exports.getInstalledExtensions = getInstalledExtensions;

package/files/extension/writer.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Write the Makefile for the extension.
+ */
+export declare const writeExtensionMakefile: (outputPath: string, extname: string, version: string) => void;
+/**
+ * Generate content for a .control file
+ * https://www.postgresql.org/docs/current/extend-extensions.html
+ */
+export declare function generateControlFileContent(options: {
+    name: string;
+    version: string;
+    comment?: string;
+    requires?: string[];
+    default_version?: string;
+    relocatable?: boolean;
+    superuser?: boolean;
+    schema?: string;
+    module_pathname?: string;
+}): string;
+/**
+ * Write the control file for the extension.
+ */
+export declare const writeExtensionControlFile: (outputPath: string, extname: string, extensions: string[], version: string) => void;
+/**
+ * Interface for extension information
+ */
+export interface ExtensionInfo {
+    extname: string;
+    packageDir: string;
+    version: string;
+    Makefile: string;
+    controlFile: string;
+    sqlFile: string;
+}
+/**
+ * Write control and Makefile for the extension with given data.
+ * If extInfo is not provided, it will be generated from packageDir.
+ */
+export declare const writeExtensions: (packageDir: string, extensions: string[], extInfo?: ExtensionInfo) => void;

package/files/extension/writer.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeExtensions = exports.writeExtensionControlFile = exports.writeExtensionMakefile = void 0;
+exports.generateControlFileContent = generateControlFileContent;
+const fs_1 = require("fs");
+const reader_1 = require("./reader");
+/**
+ * Write the Makefile for the extension.
+ */
+const writeExtensionMakefile = (outputPath, extname, version) => {
+    const content = `EXTENSION = ${extname}
+DATA = sql/${extname}--${version}.sql
+
+PG_CONFIG = pg_config
+PGXS := $(shell $(PG_CONFIG) --pgxs)
+include $(PGXS)
+  `;
+    (0, fs_1.writeFileSync)(outputPath, content);
+};
+exports.writeExtensionMakefile = writeExtensionMakefile;
+/**
+ * Generate content for a .control file
+ * https://www.postgresql.org/docs/current/extend-extensions.html
+ */
+function generateControlFileContent(options) {
+    const { name, version, comment = `${name} extension`, requires = [], default_version = version, relocatable = false, superuser = false, schema, module_pathname } = options;
+    let content = `# ${name} extension
+comment = '${comment}'
+default_version = '${default_version}'
+`;
+    if (module_pathname) {
+        content += `module_pathname = '${module_pathname}'\n`;
+    }
+    else {
+        content += `module_pathname = '$libdir/${name}'\n`;
+    }
+    if (requires.length > 0) {
+        content += `requires = '${requires.join(',')}'\n`;
+    }
+    content += `relocatable = ${relocatable}
+superuser = ${superuser}\n`;
+    if (schema) {
+        content += `schema = ${schema}\n`;
+    }
+    return content;
+}
+/**
+ * Write the control file for the extension.
+ */
+const writeExtensionControlFile = (outputPath, extname, extensions, version) => {
+    const content = generateControlFileContent({
+        name: extname,
+        version,
+        requires: extensions
+    });
+    (0, fs_1.writeFileSync)(outputPath, content);
+};
+exports.writeExtensionControlFile = writeExtensionControlFile;
+/**
+ * Write control and Makefile for the extension with given data.
+ * If extInfo is not provided, it will be generated from packageDir.
+ */
+const writeExtensions = (packageDir, extensions, extInfo) => {
+    // If extInfo is not provided, get it from packageDir
+    const info = extInfo || (0, reader_1.getExtensionInfo)(packageDir);
+    const { controlFile, Makefile, extname, version } = info;
+    (0, exports.writeExtensionControlFile)(controlFile, extname, extensions, version);
+    (0, exports.writeExtensionMakefile)(Makefile, extname, version);
+};
+exports.writeExtensions = writeExtensions;

package/files/index.d.ts

@@ -0,0 +1,5 @@
+export * from './extension';
+export * from './plan';
+export * from './sql';
+export * from './sql-scripts';
+export * from './types';

package/files/index.js

@@ -0,0 +1,22 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Re-export all functionality from package-files
+__exportStar(require("./extension"), exports);
+__exportStar(require("./plan"), exports);
+__exportStar(require("./sql"), exports);
+__exportStar(require("./sql-scripts"), exports);
+__exportStar(require("./types"), exports);

package/files/plan/generator.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Get a timestamp for the plan file
+ */
+export declare function getNow(): string;
+export interface PlanEntry {
+    change: string;
+    dependencies: string[];
+    comment?: string;
+}
+export interface GeneratePlanOptions {
+    moduleName: string;
+    uri?: string;
+    entries: PlanEntry[];
+}
+/**
+ * Generate a plan file content from structured data
+ */
+export declare function generatePlan(options: GeneratePlanOptions): string;
+/**
+ * Write a generated plan file to disk
+ */
+export declare function writePlan(planPath: string, plan: string): void;

package/files/plan/generator.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNow = getNow;
+exports.generatePlan = generatePlan;
+exports.writePlan = writePlan;
+const fs_1 = __importDefault(require("fs"));
+/**
+ * Get a UTC timestamp string
+ */
+function getUTCTimestamp(d = new Date()) {
+    return (d.getUTCFullYear() +
+        '-' + String(d.getUTCMonth() + 1).padStart(2, '0') +
+        '-' + String(d.getUTCDate()).padStart(2, '0') +
+        'T' + String(d.getUTCHours()).padStart(2, '0') +
+        ':' + String(d.getUTCMinutes()).padStart(2, '0') +
+        ':' + String(d.getUTCSeconds()).padStart(2, '0') +
+        'Z');
+}
+/**
+ * Get a timestamp for the plan file
+ */
+function getNow() {
+    return process.env.NODE_ENV === 'test'
+        ? getUTCTimestamp(new Date('2017-08-11T08:11:51Z'))
+        : getUTCTimestamp(new Date());
+}
+/**
+ * Generate a plan file content from structured data
+ */
+function generatePlan(options) {
+    const { moduleName, uri, entries } = options;
+    const now = getNow();
+    const planfile = [
+        `%syntax-version=1.0.0`,
+        `%project=${moduleName}`,
+        `%uri=${uri || moduleName}`
+    ];
+    // Generate the plan entries
+    entries.forEach(entry => {
+        if (entry.dependencies && entry.dependencies.length > 0) {
+            planfile.push(`${entry.change} [${entry.dependencies.join(' ')}] ${now} launchql <launchql@5b0c196eeb62>${entry.comment ? ` # ${entry.comment}` : ''}`);
+        }
+        else {
+            planfile.push(`${entry.change} ${now} launchql <launchql@5b0c196eeb62>${entry.comment ? ` # ${entry.comment}` : ''}`);
+        }
+    });
+    return planfile.join('\n');
+}
+/**
+ * Write a generated plan file to disk
+ */
+function writePlan(planPath, plan) {
+    fs_1.default.writeFileSync(planPath, plan);
+}

package/files/plan/index.d.ts

@@ -0,0 +1,4 @@
+export * from './generator';
+export * from './parser';
+export * from './validators';
+export * from './writer';

package/files/plan/index.js

@@ -0,0 +1,21 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Re-export all plan functionality
+__exportStar(require("./generator"), exports);
+__exportStar(require("./parser"), exports);
+__exportStar(require("./validators"), exports);
+__exportStar(require("./writer"), exports);

package/files/plan/parser.d.ts

@@ -0,0 +1,27 @@
+import { ExtendedPlanFile, ParseResult, PlanFile } from '../types';
+/**
+ * Parse a Sqitch plan file with full validation
+ * Supports both changes and tags
+ */
+export declare function parsePlanFile(planPath: string): ParseResult<ExtendedPlanFile>;
+/**
+ * Resolve a reference within a plan file context
+ * Handles symbolic references (HEAD, ROOT) and relative references
+ */
+export declare function resolveReference(ref: string, plan: ExtendedPlanFile, currentPackage?: string): {
+    change?: string;
+    tag?: string;
+    error?: string;
+};
+/**
+ * Simple plan file parser without validation (for backwards compatibility)
+ */
+export declare function parsePlanFileSimple(planPath: string): PlanFile;
+/**
+ * Get all change names from a plan file
+ */
+export declare function getChanges(planPath: string): string[];
+/**
+ * Get the latest (last) change from a plan file
+ */
+export declare function getLatestChange(planPath: string): string;