@wbce/projen-d9 0.0.28 → 0.1.1

package/lib/cli/commands/save/check-unsaved.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkUnsaved = checkUnsaved;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const promises_2 = require("readline/promises");
+const stream_1 = require("stream");
+const cli_1 = require("./cli");
+const save_snapshot_1 = require("./save-snapshot");
+const logger_1 = require("../../logger");
+const WORKTREE = 'node_modules/.cache/d9-plumbing/last-save';
+function collect(onData) {
+    return new stream_1.Writable({
+        write: (chunk, _encoding, next) => {
+            onData(chunk.toString());
+            next();
+        },
+    });
+}
+async function confirm(yes) {
+    if (yes) {
+        return;
+    }
+    if (!process.stdin.isTTY) {
+        throw new Error('no TTY to confirm, use --yes to proceed');
+    }
+    const rl = (0, promises_2.createInterface)({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await rl.question('Are you sure? (y/N) ');
+        if (answer.trim().toLowerCase() !== 'y') {
+            throw new Error('aborted');
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
+/**
+ * Dumps the destination into a worktree checked out at `lastSave`, and fails if the dump differs from that commit.
+ */
+async function checkUnsaved(opts) {
+    if (opts.lastSave === undefined) {
+        throw new Error('--last-save <commit> is required (or --no-last-save to bypass the check)');
+    }
+    if (opts.lastSave === false) {
+        logger_1.logger.warn('Non saved updates may be erased in this environment. Are you sure ?');
+        await confirm(opts.yes);
+        return;
+    }
+    logger_1.logger.info(`Checking out the last save ${opts.lastSave} into a temporary worktree`);
+    const cli = new cli_1.Cli();
+    // the worktree holds the whole repository: the project lives at the same path inside it as in the current checkout
+    let prefix = '';
+    await cli.command('git', ['rev-parse', '--show-prefix'], { stdout: collect((data) => prefix += data) });
+    const projectInWorktree = (0, path_1.join)(WORKTREE, prefix.trim());
+    await (0, promises_1.rm)(WORKTREE, { recursive: true, force: true });
+    await cli.command('git', ['worktree', 'prune']);
+    await cli.command('git', ['worktree', 'add', '--detach', WORKTREE, opts.lastSave]);
+    let status = '';
+    const cwd = process.cwd();
+    try {
+        process.chdir(projectInWorktree);
+        logger_1.logger.info(`Dumping the current database to compare it with ${opts.lastSave}`);
+        await (0, save_snapshot_1.saveSQLSnapshot)(opts.db, { cedar: false });
+        process.chdir(cwd);
+        await cli.command('git', ['-C', projectInWorktree, 'status', '--porcelain', '--', 'sql'], {
+            stdout: collect((data) => status += data),
+        });
+    }
+    finally {
+        process.chdir(cwd);
+        await cli.command('git', ['worktree', 'remove', '--force', WORKTREE]);
+    }
+    if (status.trim()) {
+        logger_1.logger.error(`\n${status}`);
+        throw new Error('This environment has unsaved changes (see the files above). '
+            + 'Run `save` from this environment, commit, merge, then run `apply-schema` again.');
+    }
+    logger_1.logger.info(`No unsaved changes since ${opts.lastSave}`);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"check-unsaved.js","sourceRoot":"","sources":["../../../../src/cli/commands/save/check-unsaved.ts"],"names":[],"mappings":"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","sourcesContent":["import { rm } from 'fs/promises';\nimport { join } from 'path';\nimport { createInterface } from 'readline/promises';\nimport { Writable } from 'stream';\nimport { Cli } from './cli';\nimport { DbConfig } from './env';\nimport { saveSQLSnapshot } from './save-snapshot';\nimport { logger } from '../../logger';\n\nconst WORKTREE = 'node_modules/.cache/d9-plumbing/last-save';\n\nfunction collect(onData: (data: string) => void) {\n  return new Writable({\n    write: (chunk, _encoding, next) => {\n      onData(chunk.toString());\n      next();\n    },\n  });\n}\n\nasync function confirm(yes: boolean) {\n  if (yes) {\n    return;\n  }\n  if (!process.stdin.isTTY) {\n    throw new Error('no TTY to confirm, use --yes to proceed');\n  }\n  const rl = createInterface({ input: process.stdin, output: process.stdout });\n  try {\n    const answer = await rl.question('Are you sure? (y/N) ');\n    if (answer.trim().toLowerCase() !== 'y') {\n      throw new Error('aborted');\n    }\n  } finally {\n    rl.close();\n  }\n}\n\n/**\n * Dumps the destination into a worktree checked out at `lastSave`, and fails if the dump differs from that commit.\n */\nexport async function checkUnsaved(opts: { lastSave?: string | false; yes: boolean; db: DbConfig }) {\n  if (opts.lastSave === undefined) {\n    throw new Error('--last-save <commit> is required (or --no-last-save to bypass the check)');\n  }\n  if (opts.lastSave === false) {\n    logger.warn('Non saved updates may be erased in this environment. Are you sure ?');\n    await confirm(opts.yes);\n    return;\n  }\n\n  logger.info(`Checking out the last save ${opts.lastSave} into a temporary worktree`);\n  const cli = new Cli();\n  // the worktree holds the whole repository: the project lives at the same path inside it as in the current checkout\n  let prefix = '';\n  await cli.command('git', ['rev-parse', '--show-prefix'], { stdout: collect((data) => prefix += data) });\n  const projectInWorktree = join(WORKTREE, prefix.trim());\n  await rm(WORKTREE, { recursive: true, force: true });\n  await cli.command('git', ['worktree', 'prune']);\n  await cli.command('git', ['worktree', 'add', '--detach', WORKTREE, opts.lastSave]);\n\n  let status = '';\n  const cwd = process.cwd();\n  try {\n    process.chdir(projectInWorktree);\n    logger.info(`Dumping the current database to compare it with ${opts.lastSave}`);\n    await saveSQLSnapshot(opts.db, { cedar: false });\n    process.chdir(cwd);\n    await cli.command('git', ['-C', projectInWorktree, 'status', '--porcelain', '--', 'sql'], {\n      stdout: collect((data) => status += data),\n    });\n  } finally {\n    process.chdir(cwd);\n    await cli.command('git', ['worktree', 'remove', '--force', WORKTREE]);\n  }\n\n  if (status.trim()) {\n    logger.error(`\\n${status}`);\n    throw new Error(\n      'This environment has unsaved changes (see the files above). '\n      + 'Run `save` from this environment, commit, merge, then run `apply-schema` again.',\n    );\n  }\n  logger.info(`No unsaved changes since ${opts.lastSave}`);\n}\n"]}

package/lib/cli/commands/save/env.d.ts

@@ -0,0 +1,37 @@
+import type { DriverConfig } from '@wbce-d9/storage';
+export interface DbConfig {
+    host: string;
+    port: number;
+    user: string;
+    pwd: string;
+    database: string;
+    ssl?: boolean;
+    commonFolderName: string;
+}
+export interface DbFlags {
+    host?: string;
+    port?: string;
+    user?: string;
+    password?: string;
+    database?: string;
+    ssl?: boolean;
+    commonFolder?: string;
+}
+export interface StorageFlags {
+    storageConfig?: string[];
+    intermediateStorageConfig?: string[];
+    files?: boolean;
+}
+export declare function resolveDbConfig(flags: DbFlags): Promise<DbConfig>;
+export declare function resolveCurrentStorage(flags: StorageFlags): Promise<DriverConfig>;
+/** The intermediate storage, or `undefined` when no driver is configured. */
+export declare function findIntermediateStorage(flags: StorageFlags): Promise<DriverConfig | undefined>;
+export declare function resolveIntermediateStorage(flags: StorageFlags): Promise<DriverConfig>;
+/**
+ * The storages to sync files between, or `undefined` when the sync is disabled
+ * (`--no-files`, SKIP_FILE_SYNC) or no intermediate storage is configured.
+ */
+export declare function resolveFileSync(flags: StorageFlags, direction: 'push' | 'pull'): Promise<{
+    origin: DriverConfig;
+    destination: DriverConfig;
+} | undefined>;

package/lib/cli/commands/save/env.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDbConfig = resolveDbConfig;
+exports.resolveCurrentStorage = resolveCurrentStorage;
+exports.findIntermediateStorage = findIntermediateStorage;
+exports.resolveIntermediateStorage = resolveIntermediateStorage;
+exports.resolveFileSync = resolveFileSync;
+const logger_1 = require("../../logger");
+const plumbing_config_1 = require("../../plumbing-config");
+// @wbce-d9/api is not a dependency of this package: it is resolved from the user's d9 project.
+// Specifiers are kept in variables so tsc does not try to resolve them.
+const envModule = '@wbce-d9/api/env';
+const configFromEnvModule = '@wbce-d9/api/utils/get-config-from-env';
+async function loadD9Env() {
+    const { getEnv } = (await Promise.resolve(`${envModule}`).then(s => require(s)));
+    const { getConfigFromEnv } = (await Promise.resolve(`${configFromEnvModule}`).then(s => require(s)));
+    return { env: getEnv(), getConfigFromEnv };
+}
+async function resolveDbConfig(flags) {
+    const { env, getConfigFromEnv } = await loadD9Env();
+    const config = {
+        host: flags.host ?? env.DB_HOST,
+        port: Number(flags.port ?? env.DB_PORT ?? 5432),
+        user: flags.user ?? env.DB_USER,
+        pwd: flags.password ?? env.DB_PASSWORD,
+        database: flags.database ?? env.DB_DATABASE,
+        // getConfigFromEnv also picks up nested DB_SSL__* keys (e.g. DB_SSL__REJECT_UNAUTHORIZED)
+        ssl: flags.ssl ?? Boolean(getConfigFromEnv('DB_').ssl),
+        commonFolderName: flags.commonFolder ?? env.COMMON_FOLDER_NAME ?? (0, plumbing_config_1.readPlumbingConfig)().commonFolderName ?? 'd9-plumbing-common',
+    };
+    const missing = Object.entries(config).filter(([, value]) => value === undefined).map(([key]) => key);
+    if (missing.length > 0) {
+        throw new Error(`missing database configuration: ${missing.join(', ')} (use flags or DB_* environment variables)`);
+    }
+    return config;
+}
+function toDriverConfig({ driver, ...options }) {
+    return { driver, options };
+}
+async function resolveCurrentStorage(flags) {
+    const { env, getConfigFromEnv } = await loadD9Env();
+    const location = String(env.STORAGE_LOCATIONS ?? '').split(',')[0].trim();
+    const config = location ? getConfigFromEnv(`STORAGE_${location.toUpperCase()}_`) : {};
+    applyConfigFlags(config, '--storage-config', flags.storageConfig);
+    if (!config.driver) {
+        throw new Error('no storage driver found (use STORAGE_LOCATIONS and STORAGE_<LOCATION>_DRIVER or --storage-config driver=...)');
+    }
+    return toDriverConfig(config);
+}
+function setPath(target, path, value) {
+    const keys = path.split('.');
+    const last = keys.pop();
+    let current = target;
+    for (const key of keys) {
+        current[key] = current[key] ?? {};
+        current = current[key];
+    }
+    current[last] = value;
+}
+function applyConfigFlags(config, flag, entries = []) {
+    for (const entry of entries) {
+        const separator = entry.indexOf('=');
+        if (separator === -1) {
+            throw new Error(`invalid ${flag} "${entry}", expected key=value`);
+        }
+        setPath(config, entry.slice(0, separator), entry.slice(separator + 1));
+    }
+}
+/** The intermediate storage, or `undefined` when no driver is configured. */
+async function findIntermediateStorage(flags) {
+    const { env, getConfigFromEnv } = await loadD9Env();
+    let config = {};
+    const file = (0, plumbing_config_1.readPlumbingConfig)().intermediateStorage;
+    if (file) {
+        config = { driver: file.driver, ...file.options };
+        for (const [key, envName] of Object.entries(file.secretEnv ?? {})) {
+            config[key] = env[envName];
+        }
+    }
+    config = { ...config, ...getConfigFromEnv('INTERMEDIATE_STORAGE_') };
+    applyConfigFlags(config, '--intermediate-storage-config', flags.intermediateStorageConfig);
+    return config.driver ? toDriverConfig(config) : undefined;
+}
+async function resolveIntermediateStorage(flags) {
+    const config = await findIntermediateStorage(flags);
+    if (!config) {
+        throw new Error(`no intermediate storage driver found (use intermediateStorage in ${plumbing_config_1.PLUMBING_CONFIG_FILE}, INTERMEDIATE_STORAGE_DRIVER or --intermediate-storage-config driver=...)`);
+    }
+    return config;
+}
+/**
+ * The storages to sync files between, or `undefined` when the sync is disabled
+ * (`--no-files`, SKIP_FILE_SYNC) or no intermediate storage is configured.
+ */
+async function resolveFileSync(flags, direction) {
+    const { env } = await loadD9Env();
+    if (flags.files === false || env.SKIP_FILE_SYNC === true || env.SKIP_FILE_SYNC === 'true') {
+        logger_1.logger.info('File sync disabled, skipping it');
+        return undefined;
+    }
+    const intermediate = await findIntermediateStorage(flags);
+    if (!intermediate) {
+        logger_1.logger.info('No intermediate storage configured, skipping the file sync');
+        return undefined;
+    }
+    const current = await resolveCurrentStorage(flags);
+    return direction === 'push'
+        ? { origin: current, destination: intermediate }
+        : { origin: intermediate, destination: current };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"env.js","sourceRoot":"","sources":["../../../../src/cli/commands/save/env.ts"],"names":[],"mappings":";;AA2CA,0CAiBC;AAMD,sDASC;AAwBD,0DAiBC;AAED,gEAMC;AAMD,0CAeC;AAhJD,yCAAsC;AACtC,2DAAiF;AA4BjF,+FAA+F;AAC/F,wEAAwE;AACxE,MAAM,SAAS,GAAG,kBAAkB,CAAC;AACrC,MAAM,mBAAmB,GAAG,wCAAwC,CAAC;AAErE,KAAK,UAAU,SAAS;IACtB,MAAM,EAAE,MAAM,EAAE,GAAG,CAAC,yBAAa,SAAS,yBAAC,CAA0C,CAAC;IACtF,MAAM,EAAE,gBAAgB,EAAE,GAAG,CAAC,yBAAa,mBAAmB,yBAAC,CAE9D,CAAC;IACF,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,gBAAgB,EAAE,CAAC;AAC7C,CAAC;AAEM,KAAK,UAAU,eAAe,CAAC,KAAc;IAClD,MAAM,EAAE,GAAG,EAAE,gBAAgB,EAAE,GAAG,MAAM,SAAS,EAAE,CAAC;IACpD,MAAM,MAAM,GAAG;QACb,IAAI,EAAE,KAAK,CAAC,IAAI,IAAI,GAAG,CAAC,OAAO;QAC/B,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,IAAI,IAAI,GAAG,CAAC,OAAO,IAAI,IAAI,CAAC;QAC/C,IAAI,EAAE,KAAK,CAAC,IAAI,IAAI,GAAG,CAAC,OAAO;QAC/B,GAAG,EAAE,KAAK,CAAC,QAAQ,IAAI,GAAG,CAAC,WAAW;QACtC,QAAQ,EAAE,KAAK,CAAC,QAAQ,IAAI,GAAG,CAAC,WAAW;QAC3C,0FAA0F;QAC1F,GAAG,EAAE,KAAK,CAAC,GAAG,IAAI,OAAO,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC;QACtD,gBAAgB,EAAE,KAAK,CAAC,YAAY,IAAI,GAAG,CAAC,kBAAkB,IAAI,IAAA,oCAAkB,GAAE,CAAC,gBAAgB,IAAI,oBAAoB;KAChI,CAAC;IACF,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC;IACtG,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACvB,MAAM,IAAI,KAAK,CAAC,mCAAmC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,4CAA4C,CAAC,CAAC;IACrH,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,SAAS,cAAc,CAAC,EAAE,MAAM,EAAE,GAAG,OAAO,EAAuB;IACjE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;AAC7B,CAAC;AAEM,KAAK,UAAU,qBAAqB,CAAC,KAAmB;IAC7D,MAAM,EAAE,GAAG,EAAE,gBAAgB,EAAE,GAAG,MAAM,SAAS,EAAE,CAAC;IACpD,MAAM,QAAQ,GAAG,MAAM,CAAC,GAAG,CAAC,iBAAiB,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IAC1E,MAAM,MAAM,GAAG,QAAQ,CAAC,CAAC,CAAC,gBAAgB,CAAC,WAAW,QAAQ,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IACtF,gBAAgB,CAAC,MAAM,EAAE,kBAAkB,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC;IAClE,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;QACnB,MAAM,IAAI,KAAK,CAAC,8GAA8G,CAAC,CAAC;IAClI,CAAC;IACD,OAAO,cAAc,CAAC,MAAM,CAAC,CAAC;AAChC,CAAC;AAED,SAAS,OAAO,CAAC,MAA2B,EAAE,IAAY,EAAE,KAAa;IACvE,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC7B,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,EAAG,CAAC;IACzB,IAAI,OAAO,GAAG,MAAM,CAAC;IACrB,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,OAAO,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;QAClC,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IACzB,CAAC;IACD,OAAO,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC;AACxB,CAAC;AAED,SAAS,gBAAgB,CAAC,MAA2B,EAAE,IAAY,EAAE,UAAoB,EAAE;IACzF,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAC5B,MAAM,SAAS,GAAG,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QACrC,IAAI,SAAS,KAAK,CAAC,CAAC,EAAE,CAAC;YACrB,MAAM,IAAI,KAAK,CAAC,WAAW,IAAI,KAAK,KAAK,uBAAuB,CAAC,CAAC;QACpE,CAAC;QACD,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,SAAS,GAAG,CAAC,CAAC,CAAC,CAAC;IACzE,CAAC;AACH,CAAC;AAED,6EAA6E;AACtE,KAAK,UAAU,uBAAuB,CAAC,KAAmB;IAC/D,MAAM,EAAE,GAAG,EAAE,gBAAgB,EAAE,GAAG,MAAM,SAAS,EAAE,CAAC;IACpD,IAAI,MAAM,GAAwB,EAAE,CAAC;IAErC,MAAM,IAAI,GAAG,IAAA,oCAAkB,GAAE,CAAC,mBAAmB,CAAC;IACtD,IAAI,IAAI,EAAE,CAAC;QACT,MAAM,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC;QAClD,KAAK,MAAM,CAAC,GAAG,EAAE,OAAO,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,IAAI,EAAE,CAAC,EAAE,CAAC;YAClE,MAAM,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC,OAAO,CAAC,CAAC;QAC7B,CAAC;IACH,CAAC;IAED,MAAM,GAAG,EAAE,GAAG,MAAM,EAAE,GAAG,gBAAgB,CAAC,uBAAuB,CAAC,EAAE,CAAC;IAErE,gBAAgB,CAAC,MAAM,EAAE,+BAA+B,EAAE,KAAK,CAAC,yBAAyB,CAAC,CAAC;IAE3F,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AAC5D,CAAC;AAEM,KAAK,UAAU,0BAA0B,CAAC,KAAmB;IAClE,MAAM,MAAM,GAAG,MAAM,uBAAuB,CAAC,KAAK,CAAC,CAAC;IACpD,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,MAAM,IAAI,KAAK,CAAC,oEAAoE,sCAAoB,4EAA4E,CAAC,CAAC;IACxL,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;GAGG;AACI,KAAK,UAAU,eAAe,CAAC,KAAmB,EAAE,SAA0B;IACnF,MAAM,EAAE,GAAG,EAAE,GAAG,MAAM,SAAS,EAAE,CAAC;IAClC,IAAI,KAAK,CAAC,KAAK,KAAK,KAAK,IAAI,GAAG,CAAC,cAAc,KAAK,IAAI,IAAI,GAAG,CAAC,cAAc,KAAK,MAAM,EAAE,CAAC;QAC1F,eAAM,CAAC,IAAI,CAAC,iCAAiC,CAAC,CAAC;QAC/C,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,MAAM,YAAY,GAAG,MAAM,uBAAuB,CAAC,KAAK,CAAC,CAAC;IAC1D,IAAI,CAAC,YAAY,EAAE,CAAC;QAClB,eAAM,CAAC,IAAI,CAAC,4DAA4D,CAAC,CAAC;QAC1E,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,MAAM,OAAO,GAAG,MAAM,qBAAqB,CAAC,KAAK,CAAC,CAAC;IACnD,OAAO,SAAS,KAAK,MAAM;QACzB,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE;QAChD,CAAC,CAAC,EAAE,MAAM,EAAE,YAAY,EAAE,WAAW,EAAE,OAAO,EAAE,CAAC;AACrD,CAAC","sourcesContent":["import type { DriverConfig } from '@wbce-d9/storage';\nimport { logger } from '../../logger';\nimport { PLUMBING_CONFIG_FILE, readPlumbingConfig } from '../../plumbing-config';\n\nexport interface DbConfig {\n  host: string;\n  port: number;\n  user: string;\n  pwd: string;\n  database: string;\n  ssl?: boolean;\n  commonFolderName: string;\n}\n\nexport interface DbFlags {\n  host?: string;\n  port?: string;\n  user?: string;\n  password?: string;\n  database?: string;\n  ssl?: boolean;\n  commonFolder?: string;\n}\n\nexport interface StorageFlags {\n  storageConfig?: string[];\n  intermediateStorageConfig?: string[];\n  files?: boolean;\n}\n\n// @wbce-d9/api is not a dependency of this package: it is resolved from the user's d9 project.\n// Specifiers are kept in variables so tsc does not try to resolve them.\nconst envModule = '@wbce-d9/api/env';\nconst configFromEnvModule = '@wbce-d9/api/utils/get-config-from-env';\n\nasync function loadD9Env() {\n  const { getEnv } = (await import(envModule)) as { getEnv: () => Record<string, any> };\n  const { getConfigFromEnv } = (await import(configFromEnvModule)) as {\n    getConfigFromEnv: (prefix: string) => Record<string, any>;\n  };\n  return { env: getEnv(), getConfigFromEnv };\n}\n\nexport async function resolveDbConfig(flags: DbFlags): Promise<DbConfig> {\n  const { env, getConfigFromEnv } = await loadD9Env();\n  const config = {\n    host: flags.host ?? env.DB_HOST,\n    port: Number(flags.port ?? env.DB_PORT ?? 5432),\n    user: flags.user ?? env.DB_USER,\n    pwd: flags.password ?? env.DB_PASSWORD,\n    database: flags.database ?? env.DB_DATABASE,\n    // getConfigFromEnv also picks up nested DB_SSL__* keys (e.g. DB_SSL__REJECT_UNAUTHORIZED)\n    ssl: flags.ssl ?? Boolean(getConfigFromEnv('DB_').ssl),\n    commonFolderName: flags.commonFolder ?? env.COMMON_FOLDER_NAME ?? readPlumbingConfig().commonFolderName ?? 'd9-plumbing-common',\n  };\n  const missing = Object.entries(config).filter(([, value]) => value === undefined).map(([key]) => key);\n  if (missing.length > 0) {\n    throw new Error(`missing database configuration: ${missing.join(', ')} (use flags or DB_* environment variables)`);\n  }\n  return config;\n}\n\nfunction toDriverConfig({ driver, ...options }: Record<string, any>): DriverConfig {\n  return { driver, options };\n}\n\nexport async function resolveCurrentStorage(flags: StorageFlags): Promise<DriverConfig> {\n  const { env, getConfigFromEnv } = await loadD9Env();\n  const location = String(env.STORAGE_LOCATIONS ?? '').split(',')[0].trim();\n  const config = location ? getConfigFromEnv(`STORAGE_${location.toUpperCase()}_`) : {};\n  applyConfigFlags(config, '--storage-config', flags.storageConfig);\n  if (!config.driver) {\n    throw new Error('no storage driver found (use STORAGE_LOCATIONS and STORAGE_<LOCATION>_DRIVER or --storage-config driver=...)');\n  }\n  return toDriverConfig(config);\n}\n\nfunction setPath(target: Record<string, any>, path: string, value: string) {\n  const keys = path.split('.');\n  const last = keys.pop()!;\n  let current = target;\n  for (const key of keys) {\n    current[key] = current[key] ?? {};\n    current = current[key];\n  }\n  current[last] = value;\n}\n\nfunction applyConfigFlags(config: Record<string, any>, flag: string, entries: string[] = []) {\n  for (const entry of entries) {\n    const separator = entry.indexOf('=');\n    if (separator === -1) {\n      throw new Error(`invalid ${flag} \"${entry}\", expected key=value`);\n    }\n    setPath(config, entry.slice(0, separator), entry.slice(separator + 1));\n  }\n}\n\n/** The intermediate storage, or `undefined` when no driver is configured. */\nexport async function findIntermediateStorage(flags: StorageFlags): Promise<DriverConfig | undefined> {\n  const { env, getConfigFromEnv } = await loadD9Env();\n  let config: Record<string, any> = {};\n\n  const file = readPlumbingConfig().intermediateStorage;\n  if (file) {\n    config = { driver: file.driver, ...file.options };\n    for (const [key, envName] of Object.entries(file.secretEnv ?? {})) {\n      config[key] = env[envName];\n    }\n  }\n\n  config = { ...config, ...getConfigFromEnv('INTERMEDIATE_STORAGE_') };\n\n  applyConfigFlags(config, '--intermediate-storage-config', flags.intermediateStorageConfig);\n\n  return config.driver ? toDriverConfig(config) : undefined;\n}\n\nexport async function resolveIntermediateStorage(flags: StorageFlags): Promise<DriverConfig> {\n  const config = await findIntermediateStorage(flags);\n  if (!config) {\n    throw new Error(`no intermediate storage driver found (use intermediateStorage in ${PLUMBING_CONFIG_FILE}, INTERMEDIATE_STORAGE_DRIVER or --intermediate-storage-config driver=...)`);\n  }\n  return config;\n}\n\n/**\n * The storages to sync files between, or `undefined` when the sync is disabled\n * (`--no-files`, SKIP_FILE_SYNC) or no intermediate storage is configured.\n */\nexport async function resolveFileSync(flags: StorageFlags, direction: 'push' | 'pull'): Promise<{ origin: DriverConfig; destination: DriverConfig } | undefined> {\n  const { env } = await loadD9Env();\n  if (flags.files === false || env.SKIP_FILE_SYNC === true || env.SKIP_FILE_SYNC === 'true') {\n    logger.info('File sync disabled, skipping it');\n    return undefined;\n  }\n  const intermediate = await findIntermediateStorage(flags);\n  if (!intermediate) {\n    logger.info('No intermediate storage configured, skipping the file sync');\n    return undefined;\n  }\n  const current = await resolveCurrentStorage(flags);\n  return direction === 'push'\n    ? { origin: current, destination: intermediate }\n    : { origin: intermediate, destination: current };\n}\n"]}

package/lib/cli/commands/save/save-snapshot.d.ts

@@ -0,0 +1,4 @@
+import { DbConfig } from './env';
+export declare function saveSQLSnapshot(dbConfig: DbConfig, opts?: {
+    cedar?: boolean;
+}): Promise<void>;

package/lib/cli/commands/save/save-snapshot.js

@@ -0,0 +1,233 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveSQLSnapshot = saveSQLSnapshot;
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const promises_2 = require("stream/promises");
+const pg = require("pg");
+const pg_copy_streams_1 = require("pg-copy-streams");
+const cli_1 = require("./cli");
+const atlas_1 = require("../../atlas");
+const logger_1 = require("../../logger");
+const d9_to_cedar_1 = require("../cedar/d9-to-cedar");
+async function formateSerial() {
+    //this can be removed once this is fixed :
+    //https://github.com/ariga/atlas/issues/2492
+    const sqlSchema = (await (0, promises_1.readFile)('./sql/schema.sql')).toString();
+    let pattern = /(".*")\s+integer\s+NOT\s+NULL\s+DEFAULT\s+nextval\(.*::regclass\)/g;
+    let replacement = '$1 serial NOT NULL';
+    let endSchema = sqlSchema.replace(pattern, replacement);
+    pattern = /(".*")\s+integer\s+DEFAULT\s+nextval\(.*::regclass\)/g;
+    replacement = '$1 serial';
+    endSchema = endSchema.replace(pattern, replacement);
+    await (0, promises_1.writeFile)('./sql/schema.sql', endSchema);
+}
+async function saveSQLSnapshot(dbConfig, opts = {}) {
+    const connectionProps = {
+        user: dbConfig.user,
+        host: dbConfig.host,
+        port: dbConfig.port,
+        password: dbConfig.pwd,
+        database: dbConfig.database,
+        ...(dbConfig.ssl ? { ssl: { rejectUnauthorized: false } } : {}),
+    };
+    const cli = new cli_1.Cli();
+    await (0, promises_1.rm)('./sql/data', { recursive: true, force: true }); //we make sure we have an empty data set
+    await Promise.all([await (0, promises_1.mkdir)('sql/data', { recursive: true })]); //with recursive, there is no error if folder already exists
+    //atlas documentation : https://atlasgo.io/
+    logger_1.logger.info('Dumping the schema with atlas into ./sql/schema.sql');
+    const writeFileStream = (0, fs_1.createWriteStream)('./sql/schema.sql');
+    await cli.command(await (0, atlas_1.ensureAtlas)(), [
+        'schema', //schema only
+        'inspect',
+        '-u',
+        `postgres://${encodeURIComponent(dbConfig.user)}:${encodeURIComponent(dbConfig.pwd)}@${dbConfig.host}:${dbConfig.port}/${dbConfig.database}?sslmode=${dbConfig.ssl ? 'require' : 'disable'}`, //output file
+        '--format',
+        '{{ sql . "  " }}',
+    ], {
+        env: {
+            ...process.env,
+            ATLAS_NO_UPDATE_NOTIFIER: 'true', //if not set, atlas end a final line with "a new version of atlas is available"
+        },
+        stdout: writeFileStream,
+    });
+    await formateSerial();
+    let customTablesToDump = [];
+    let customTablesNotToDump = [];
+    try {
+        customTablesToDump = (0, fs_1.readFileSync)('./sql/tables_to_dump.txt')
+            .toString()
+            .split('\n');
+        logger_1.logger.info(`Using sql/tables_to_dump.txt (${customTablesToDump.length} tables)`);
+    }
+    catch (e) {
+        logger_1.logger.debug('no sql/tables_to_dump.txt');
+    }
+    try {
+        customTablesNotToDump = (0, fs_1.readFileSync)('./sql/tables_not_to_dump.txt')
+            .toString()
+            .split('\n');
+        logger_1.logger.info(`Using sql/tables_not_to_dump.txt (${customTablesNotToDump.length} tables)`);
+    }
+    catch (e) {
+        logger_1.logger.debug('no sql/tables_not_to_dump.txt');
+    }
+    const pgClient = new pg.Client(connectionProps);
+    await pgClient.connect();
+    try {
+        logger_1.logger.info('Dumping the data into ./sql/data');
+        let dumpedTables = 0;
+        const tables = await pgClient.query(`
+          SELECT table_name
+          FROM information_schema.tables
+          WHERE table_schema='public'
+          AND table_type='BASE TABLE';
+      `);
+        const foreignKeysToUser = await pgClient.query(`
+          SELECT
+              conname AS foreign_key_name,
+              conrelid::regclass AS table_name,
+              a.attname AS column_name,
+              confrelid::regclass AS referenced_table,
+              af.attname AS referenced_column
+          FROM
+              pg_constraint AS c
+          JOIN
+              pg_attribute AS a ON a.attnum = ANY(c.conkey) AND a.attrelid = c.conrelid
+          JOIN
+              pg_attribute AS af ON af.attnum = ANY(c.confkey) AND af.attrelid = c.confrelid
+          WHERE
+              confrelid = 'directus_users'::regclass
+      `);
+        const tableHasFgKey = {};
+        for (const foreignKey of foreignKeysToUser.rows) {
+            tableHasFgKey[foreignKey.table_name] = {
+                ...tableHasFgKey[foreignKey.table_name],
+                [foreignKey.column_name]: true,
+            };
+        }
+        for (const table of tables.rows) {
+            //the table is not in tables_not_to_dump.txt
+            //either : is a directus_ table
+            //either : the table is in tables_to_dump.txt
+            if (!customTablesNotToDump.includes(table.table_name) &&
+                ((table.table_name.startsWith('directus_') &&
+                    !(table.table_name === 'directus_users') &&
+                    !(table.table_name === 'directus_sessions') &&
+                    !(table.table_name === 'directus_revisions') &&
+                    !(table.table_name === 'directus_activity') &&
+                    !(table.table_name === 'directus_presets')) ||
+                    customTablesToDump.includes(table.table_name))) {
+                //We can not dump the user table
+                //so for all table pointing to the user table
+                //we point to a fictif ci user.
+                //for this, we find all the foreign keys pointing to directus_user (id)
+                //and we format the copy
+                const fields = await pgClient.query(`
+                  SELECT column_name
+                  FROM information_schema.columns
+                  WHERE table_name = '${table.table_name}'
+                  ORDER BY column_name;
+              `);
+                const primaryKeys = await pgClient.query(`
+                  SELECT a.attname AS pk, format_type(a.atttypid, a.atttypmod) AS data_type
+                  FROM   pg_index i
+                  JOIN   pg_attribute a ON a.attrelid = i.indrelid
+                  AND a.attnum = ANY(i.indkey)
+                  WHERE  i.indrelid = '"${table.table_name}"'::regclass
+              `);
+                const primaryKeyColumnName = primaryKeys.rows[0].pk;
+                //sql statement will look like
+                /**
+                       * SELECT id, message, '' AS user_created, '' AS user_updated
+                       * FROM directus_revisions
+                       */
+                const wbceCiUserId = '49bcde5d-90aa-4be8-ab10-f9ae1a07546f';
+                let sqlSelectStatement = 'SELECT ';
+                for (const field of fields.rows) {
+                    if (tableHasFgKey?.[table.table_name]?.[field.column_name]) {
+                        sqlSelectStatement += `CASE WHEN (t."${field.column_name}" IS NULL)   
+                  THEN t."${field.column_name}"
+                  ELSE '${wbceCiUserId}' 
+                  END AS "${field.column_name}"`;
+                    }
+                    else {
+                        sqlSelectStatement += `t."${field.column_name}"`;
+                    }
+                    sqlSelectStatement += ', ';
+                }
+                //remove last comma
+                sqlSelectStatement = sqlSelectStatement.slice(0, -2);
+                //finish statement
+                sqlSelectStatement += `  FROM "${table.table_name}" AS t`;
+                //for directus_files and directus_folders, we only want to keep some but not all files.
+                //for now, we keep all files included in the "d9-plumbing-common" folder
+                if (['directus_files', 'directus_folders'].includes(table.table_name)) {
+                    const commonFolderName = pg.escapeLiteral(dbConfig.commonFolderName);
+                    let recursiveStatement = `
+                      WITH RECURSIVE folder_tree AS (
+                      -- Anchor: the "d9-plumbing-common" folder
+                          SELECT id
+                          FROM directus_folders
+                          WHERE name = ${commonFolderName}
+                      UNION
+                      -- Recursive step: find subfolders
+                      SELECT f.id
+                      FROM directus_folders f
+                      JOIN folder_tree ft ON f.parent = ft.id
+                      )
+                  `;
+                    const folderKey = {
+                        directus_files: 'folder',
+                        directus_folders: 'parent',
+                    };
+                    sqlSelectStatement += ` WHERE t.${folderKey[table.table_name]} IN (SELECT id FROM folder_tree) `;
+                    if (table.table_name === 'directus_folders') {
+                        //also include folders targetted by a field (for example, a file field whose file will be placed on a specific folder)
+                        // and their parents
+                        recursiveStatement += ` , 
+                      folder_from_fields_tree AS (
+                              -- Anchor: Get the initial folder IDs from field options
+                              -- We cast to UUID to ensure compatibility with the folders table
+                              SELECT (options::json->>'folder')::uuid AS id
+                              FROM directus_fields                                                                                    
+                              WHERE options IS NOT NULL AND options::json->>'folder' IS NOT NULL
+                              UNION
+                            
+                              -- Recursive step: find the parent of each folder
+                              -- This "climbs" the tree by matching the ID we just found 
+                              -- to a row and selecting its parent
+                              SELECT f.parent
+                              FROM directus_folders f
+                              JOIN folder_from_fields_tree ft ON f.id = ft.id
+                              WHERE f.parent IS NOT NULL
+                          )
+                      `;
+                        sqlSelectStatement += ' OR t.id IN (SELECT id FROM folder_from_fields_tree) ';
+                        sqlSelectStatement += ` OR t.name = ${commonFolderName} `; //also include the common folder
+                    }
+                    sqlSelectStatement = recursiveStatement + sqlSelectStatement;
+                }
+                sqlSelectStatement += ` ORDER BY t."${primaryKeyColumnName}"`;
+                const dbStream = pgClient.query((0, pg_copy_streams_1.to)(`COPY (${sqlSelectStatement}) TO STDOUT DELIMITER ',' CSV HEADER;`));
+                const fileStream = (0, fs_1.createWriteStream)(`./sql/data/${table.table_name}.csv`);
+                await (0, promises_2.pipeline)(dbStream, fileStream);
+                logger_1.logger.debug(`dumped ${table.table_name}`);
+                dumpedTables++;
+            }
+        }
+        logger_1.logger.info(`Dumped ${dumpedTables} tables into ./sql/data`);
+    }
+    catch (e) {
+        logger_1.logger.error('Error while dumping the data');
+        throw e;
+    }
+    finally {
+        await pgClient.end();
+    }
+    if (opts.cedar !== false) {
+        logger_1.logger.info('Generating the Cedar policies into ./permissions');
+        await (0, d9_to_cedar_1.d9ToCedar)({ permissionPath: './permissions', sqlPath: './sql/data' });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"save-snapshot.js","sourceRoot":"","sources":["../../../../src/cli/commands/save/save-snapshot.ts"],"names":[],"mappings":"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","sourcesContent":["import { createWriteStream, readFileSync } from 'fs';\nimport { mkdir, readFile, rm, writeFile } from 'fs/promises';\nimport { pipeline } from 'stream/promises';\nimport * as pg from 'pg';\nimport { to as copyTo } from 'pg-copy-streams';\nimport { Cli } from './cli';\nimport { DbConfig } from './env';\nimport { ensureAtlas } from '../../atlas';\nimport { logger } from '../../logger';\nimport { d9ToCedar } from '../cedar/d9-to-cedar';\n\nasync function formateSerial() {\n  //this can be removed once this is fixed :\n  //https://github.com/ariga/atlas/issues/2492\n  const sqlSchema = (await readFile('./sql/schema.sql')).toString();\n  let pattern =\n        /(\".*\")\\s+integer\\s+NOT\\s+NULL\\s+DEFAULT\\s+nextval\\(.*::regclass\\)/g;\n  let replacement = '$1 serial NOT NULL';\n  let endSchema = sqlSchema.replace(pattern, replacement);\n  pattern = /(\".*\")\\s+integer\\s+DEFAULT\\s+nextval\\(.*::regclass\\)/g;\n  replacement = '$1 serial';\n  endSchema = endSchema.replace(pattern, replacement);\n  await writeFile('./sql/schema.sql', endSchema);\n}\n\nexport async function saveSQLSnapshot(dbConfig: DbConfig, opts: { cedar?: boolean } = {}) {\n  const connectionProps: pg.ClientConfig = {\n    user: dbConfig.user,\n    host: dbConfig.host,\n    port: dbConfig.port,\n    password: dbConfig.pwd,\n    database: dbConfig.database,\n    ...(dbConfig.ssl ? { ssl: { rejectUnauthorized: false } } : {}),\n  };\n  const cli = new Cli();\n  await rm('./sql/data', { recursive: true, force: true }); //we make sure we have an empty data set\n  await Promise.all([await mkdir('sql/data', { recursive: true })]); //with recursive, there is no error if folder already exists\n\n  //atlas documentation : https://atlasgo.io/\n  logger.info('Dumping the schema with atlas into ./sql/schema.sql');\n  const writeFileStream = createWriteStream('./sql/schema.sql');\n  await cli.command(\n    await ensureAtlas(),\n    [\n      'schema', //schema only\n      'inspect',\n      '-u',\n      `postgres://${encodeURIComponent(dbConfig.user)}:${encodeURIComponent(dbConfig.pwd)}@${dbConfig.host}:${dbConfig.port}/${dbConfig.database}?sslmode=${dbConfig.ssl ? 'require' : 'disable'}`, //output file\n      '--format',\n      '{{ sql . \"  \" }}',\n    ],\n    {\n      env: {\n        ...process.env,\n        ATLAS_NO_UPDATE_NOTIFIER: 'true', //if not set, atlas end a final line with \"a new version of atlas is available\"\n      },\n      stdout: writeFileStream,\n    },\n  );\n  await formateSerial();\n  let customTablesToDump : string[] = [];\n  let customTablesNotToDump : string[] = [];\n  try {\n    customTablesToDump = readFileSync('./sql/tables_to_dump.txt')\n      .toString()\n      .split('\\n');\n    logger.info(`Using sql/tables_to_dump.txt (${customTablesToDump.length} tables)`);\n  } catch (e) {\n    logger.debug('no sql/tables_to_dump.txt');\n  }\n  try {\n    customTablesNotToDump = readFileSync('./sql/tables_not_to_dump.txt')\n      .toString()\n      .split('\\n');\n    logger.info(`Using sql/tables_not_to_dump.txt (${customTablesNotToDump.length} tables)`);\n  } catch (e) {\n    logger.debug('no sql/tables_not_to_dump.txt');\n  }\n  const pgClient = new pg.Client(connectionProps);\n  await pgClient.connect();\n  try {\n    logger.info('Dumping the data into ./sql/data');\n    let dumpedTables = 0;\n    const tables = await pgClient.query(`\n          SELECT table_name\n          FROM information_schema.tables\n          WHERE table_schema='public'\n          AND table_type='BASE TABLE';\n      `);\n\n    const foreignKeysToUser = await pgClient.query(`\n          SELECT\n              conname AS foreign_key_name,\n              conrelid::regclass AS table_name,\n              a.attname AS column_name,\n              confrelid::regclass AS referenced_table,\n              af.attname AS referenced_column\n          FROM\n              pg_constraint AS c\n          JOIN\n              pg_attribute AS a ON a.attnum = ANY(c.conkey) AND a.attrelid = c.conrelid\n          JOIN\n              pg_attribute AS af ON af.attnum = ANY(c.confkey) AND af.attrelid = c.confrelid\n          WHERE\n              confrelid = 'directus_users'::regclass\n      `);\n\n    const tableHasFgKey: Record<string, Record<string, boolean>> = {};\n    for (const foreignKey of foreignKeysToUser.rows) {\n      tableHasFgKey[foreignKey.table_name] = {\n        ...tableHasFgKey[foreignKey.table_name],\n        [foreignKey.column_name]: true,\n      };\n    }\n\n    for (const table of tables.rows) {\n      //the table is not in tables_not_to_dump.txt\n      //either : is a directus_ table\n      //either : the table is in tables_to_dump.txt\n      if (\n        !customTablesNotToDump.includes(table.table_name) &&\n              ((table.table_name.startsWith('directus_') &&\n                  !(table.table_name === 'directus_users') &&\n                  !(table.table_name === 'directus_sessions') &&\n                  !(table.table_name === 'directus_revisions') &&\n                  !(table.table_name === 'directus_activity') &&\n                  !(table.table_name === 'directus_presets')) ||\n                  customTablesToDump.includes(table.table_name))\n      ) {\n        //We can not dump the user table\n        //so for all table pointing to the user table\n        //we point to a fictif ci user.\n        //for this, we find all the foreign keys pointing to directus_user (id)\n        //and we format the copy\n\n        const fields = await pgClient.query(`\n                  SELECT column_name\n                  FROM information_schema.columns\n                  WHERE table_name = '${table.table_name}'\n                  ORDER BY column_name;\n              `);\n        const primaryKeys = await pgClient.query(`\n                  SELECT a.attname AS pk, format_type(a.atttypid, a.atttypmod) AS data_type\n                  FROM   pg_index i\n                  JOIN   pg_attribute a ON a.attrelid = i.indrelid\n                  AND a.attnum = ANY(i.indkey)\n                  WHERE  i.indrelid = '\"${table.table_name}\"'::regclass\n              `);\n        const primaryKeyColumnName = primaryKeys.rows[0].pk;\n\n        //sql statement will look like\n        /**\n               * SELECT id, message, '' AS user_created, '' AS user_updated\n               * FROM directus_revisions\n               */\n\n        const wbceCiUserId = '49bcde5d-90aa-4be8-ab10-f9ae1a07546f';\n\n        let sqlSelectStatement = 'SELECT ';\n        for (const field of fields.rows) {\n          if (\n            tableHasFgKey?.[table.table_name]?.[field.column_name]\n          ) {\n            sqlSelectStatement += `CASE WHEN (t.\"${field.column_name}\" IS NULL)   \n                  THEN t.\"${field.column_name}\"\n                  ELSE '${wbceCiUserId}' \n                  END AS \"${field.column_name}\"`;\n          } else {\n            sqlSelectStatement += `t.\"${field.column_name}\"`;\n          }\n          sqlSelectStatement += ', ';\n        }\n        //remove last comma\n        sqlSelectStatement = sqlSelectStatement.slice(0, -2);\n        //finish statement\n        sqlSelectStatement += `  FROM \"${table.table_name}\" AS t`;\n        //for directus_files and directus_folders, we only want to keep some but not all files.\n        //for now, we keep all files included in the \"d9-plumbing-common\" folder\n        if (['directus_files', 'directus_folders'].includes(table.table_name)) {\n          const commonFolderName = pg.escapeLiteral(dbConfig.commonFolderName);\n          let recursiveStatement = `\n                      WITH RECURSIVE folder_tree AS (\n                      -- Anchor: the \"d9-plumbing-common\" folder\n                          SELECT id\n                          FROM directus_folders\n                          WHERE name = ${commonFolderName}\n                      UNION\n                      -- Recursive step: find subfolders\n                      SELECT f.id\n                      FROM directus_folders f\n                      JOIN folder_tree ft ON f.parent = ft.id\n                      )\n                  `;\n          const folderKey : Record<string, string> = {\n            directus_files: 'folder',\n            directus_folders: 'parent',\n          };\n          sqlSelectStatement += ` WHERE t.${folderKey[table.table_name]} IN (SELECT id FROM folder_tree) `;\n          if (table.table_name === 'directus_folders') {\n            //also include folders targetted by a field (for example, a file field whose file will be placed on a specific folder)\n            // and their parents\n\n            recursiveStatement += ` , \n                      folder_from_fields_tree AS (\n                              -- Anchor: Get the initial folder IDs from field options\n                              -- We cast to UUID to ensure compatibility with the folders table\n                              SELECT (options::json->>'folder')::uuid AS id\n                              FROM directus_fields                                                                                    \n                              WHERE options IS NOT NULL AND options::json->>'folder' IS NOT NULL\n                              UNION\n                            \n                              -- Recursive step: find the parent of each folder\n                              -- This \"climbs\" the tree by matching the ID we just found \n                              -- to a row and selecting its parent\n                              SELECT f.parent\n                              FROM directus_folders f\n                              JOIN folder_from_fields_tree ft ON f.id = ft.id\n                              WHERE f.parent IS NOT NULL\n                          )\n                      `;\n            sqlSelectStatement += ' OR t.id IN (SELECT id FROM folder_from_fields_tree) ';\n            sqlSelectStatement += ` OR t.name = ${commonFolderName} `; //also include the common folder\n          }\n          sqlSelectStatement = recursiveStatement + sqlSelectStatement;\n        }\n\n        sqlSelectStatement += ` ORDER BY t.\"${primaryKeyColumnName}\"`;\n\n        const dbStream = pgClient.query(\n          copyTo(\n            `COPY (${sqlSelectStatement}) TO STDOUT DELIMITER ',' CSV HEADER;`,\n          ),\n        );\n        const fileStream = createWriteStream(\n          `./sql/data/${table.table_name}.csv`,\n        );\n        await pipeline(dbStream, fileStream);\n        logger.debug(`dumped ${table.table_name}`);\n        dumpedTables++;\n      }\n    }\n    logger.info(`Dumped ${dumpedTables} tables into ./sql/data`);\n  } catch (e) {\n    logger.error('Error while dumping the data');\n    throw e;\n  } finally {\n    await pgClient.end();\n  }\n  if (opts.cedar !== false) {\n    logger.info('Generating the Cedar policies into ./permissions');\n    await d9ToCedar({ permissionPath: './permissions', sqlPath: './sql/data' });\n  }\n}"]}

package/lib/cli/commands/save/sync-files.d.ts

@@ -0,0 +1,5 @@
+import type { DriverConfig } from '@wbce-d9/storage';
+export declare function syncFiles(opts: {
+    origin: DriverConfig;
+    destination: DriverConfig;
+}): Promise<void>;

package/lib/cli/commands/save/sync-files.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncFiles = syncFiles;
+const utils_1 = require("./utils");
+const logger_1 = require("../../logger");
+const drivers = {
+    local: '@wbce-d9/storage-driver-local',
+    s3: '@wbce-d9/storage-driver-s3',
+    gcs: '@wbce-d9/storage-driver-gcs',
+    azure: '@wbce-d9/storage-driver-azure',
+    cloudinary: '@wbce-d9/storage-driver-cloudinary',
+};
+async function syncFiles(opts) {
+    // eslint-disable-next-line import/no-extraneous-dependencies
+    const { StorageManager } = await Promise.resolve().then(() => require('@wbce-d9/storage'));
+    const storage = new StorageManager();
+    for (const { driver } of [opts.origin, opts.destination]) {
+        storage.registerDriver(driver, (await Promise.resolve(`${drivers[driver]}`).then(s => require(s))).default);
+    }
+    storage.registerLocation('origin', opts.origin);
+    storage.registerLocation('destination', opts.destination);
+    const origin = storage.location('origin');
+    const destination = storage.location('destination');
+    const files = await (0, utils_1.readCsvFile)('./sql/data/directus_files.csv');
+    logger_1.logger.info(`Syncing ${files.length} files from ${opts.origin.driver} to ${opts.destination.driver}`);
+    let copied = 0;
+    let present = 0;
+    let missing = 0;
+    for (const { filename_disk: fileId } of files) {
+        if (await destination.exists(fileId)) {
+            logger_1.logger.debug(`${fileId} already exists in destination`);
+            present++;
+            continue;
+        }
+        if (!(await origin.exists(fileId))) {
+            logger_1.logger.warn(`${fileId} does not exist in origin`);
+            missing++;
+            continue;
+        }
+        await destination.write(fileId, await origin.read(fileId));
+        logger_1.logger.debug(`${fileId} synced`);
+        copied++;
+    }
+    logger_1.logger.info(`Files synced: ${copied} copied, ${present} already present, ${missing} missing in origin`);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cli/commands/save/transfer.d.ts

@@ -0,0 +1,18 @@
+import { DbFlags, StorageFlags } from './env';
+type CheckFlags = {
+    lastSave?: string | false;
+    yes?: boolean;
+};
+export declare function saveSqlSchema(flags: DbFlags & {
+    cedar?: boolean;
+}): Promise<void>;
+export declare function applySqlSchema(flags: DbFlags): Promise<void>;
+export declare function pushFiles(flags: StorageFlags): Promise<void>;
+export declare function pullFiles(flags: StorageFlags): Promise<void>;
+export declare function checkUnsavedChanges(flags: DbFlags & CheckFlags): Promise<void>;
+export declare function save(flags: DbFlags & StorageFlags & {
+    cedar?: boolean;
+}): Promise<void>;
+export declare function applySchema(flags: DbFlags & StorageFlags & CheckFlags): Promise<void>;
+export declare function firstImport(flags: DbFlags & StorageFlags): Promise<void>;
+export {};