@wbce/projen-d9 0.0.28 → 0.1.0

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

@@ -0,0 +1,9 @@
+export declare function saveSQLSnapshot(dbConfig: {
+    host: string;
+    user: string;
+    pwd: string;
+    database: string;
+    ssl?: boolean;
+}, opts?: {
+    cedar?: boolean;
+}): Promise<void>;

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

@@ -0,0 +1,232 @@
+"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,
+        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.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 = 'd9-plumbing-common';
+                    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 { 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: {\n  host: string;\n  user: string;\n  pwd: string;\n  database: string;\n  ssl?: boolean;\n}, opts: { cedar?: boolean } = {}) {\n  const connectionProps: pg.ClientConfig = {\n    user: dbConfig.user,\n    host: dbConfig.host,\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.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 = 'd9-plumbing-common';\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 {};

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

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveSqlSchema = saveSqlSchema;
+exports.applySqlSchema = applySqlSchema;
+exports.pushFiles = pushFiles;
+exports.pullFiles = pullFiles;
+exports.checkUnsavedChanges = checkUnsavedChanges;
+exports.save = save;
+exports.applySchema = applySchema;
+exports.firstImport = firstImport;
+const pg = require("pg");
+const apply_snapshot_1 = require("./apply-snapshot");
+const check_unsaved_1 = require("./check-unsaved");
+const env_1 = require("./env");
+const save_snapshot_1 = require("./save-snapshot");
+const sync_files_1 = require("./sync-files");
+const logger_1 = require("../../logger");
+async function saveSqlSchema(flags) {
+    await (0, save_snapshot_1.saveSQLSnapshot)(await (0, env_1.resolveDbConfig)(flags), { cedar: flags.cedar });
+}
+async function applySqlSchema(flags) {
+    await (0, apply_snapshot_1.applySQLSnapshot)(await (0, env_1.resolveDbConfig)(flags));
+}
+async function pushFiles(flags) {
+    await (0, sync_files_1.syncFiles)({
+        origin: await (0, env_1.resolveCurrentStorage)(flags),
+        destination: await (0, env_1.resolveIntermediateStorage)(flags),
+    });
+}
+async function pullFiles(flags) {
+    await (0, sync_files_1.syncFiles)({
+        origin: await (0, env_1.resolveIntermediateStorage)(flags),
+        destination: await (0, env_1.resolveCurrentStorage)(flags),
+    });
+}
+async function checkUnsavedChanges(flags) {
+    await (0, check_unsaved_1.checkUnsaved)({ lastSave: flags.lastSave, yes: flags.yes ?? false, db: await (0, env_1.resolveDbConfig)(flags) });
+}
+async function save(flags) {
+    const db = await (0, env_1.resolveDbConfig)(flags);
+    const fileSync = await (0, env_1.resolveFileSync)(flags, 'push');
+    // after the snapshot, so that syncFiles reads the freshly dumped directus_files.csv
+    logger_1.logger.info(`[1/2] Saving the SQL snapshot of ${describeDb(db)} into ./sql`);
+    await (0, save_snapshot_1.saveSQLSnapshot)(db, { cedar: flags.cedar });
+    if (fileSync) {
+        logger_1.logger.info(`[2/2] Pushing files to the intermediate storage (${fileSync.origin.driver} → ${fileSync.destination.driver})`);
+        await (0, sync_files_1.syncFiles)(fileSync);
+    }
+    logger_1.logger.info('Save completed');
+}
+async function applySchema(flags) {
+    const db = await (0, env_1.resolveDbConfig)(flags);
+    const fileSync = await (0, env_1.resolveFileSync)(flags, 'pull');
+    logger_1.logger.info(`[1/3] Checking for unsaved changes on ${describeDb(db)}`);
+    await (0, check_unsaved_1.checkUnsaved)({ lastSave: flags.lastSave, yes: flags.yes ?? false, db });
+    if (fileSync) {
+        logger_1.logger.info(`[2/3] Pulling files from the intermediate storage (${fileSync.origin.driver} → ${fileSync.destination.driver})`);
+        await (0, sync_files_1.syncFiles)(fileSync);
+    }
+    logger_1.logger.info(`[3/3] Applying the SQL snapshot to ${describeDb(db)}`);
+    await (0, apply_snapshot_1.applySQLSnapshot)(db);
+    logger_1.logger.info('Schema applied');
+}
+function describeDb(db) {
+    return `${db.database}@${db.host}`;
+}
+async function isDatabaseEmpty(db) {
+    const client = new pg.Client({
+        user: db.user,
+        host: db.host,
+        password: db.pwd,
+        database: db.database,
+        ...(db.ssl ? { ssl: { rejectUnauthorized: false } } : {}),
+    });
+    await client.connect();
+    try {
+        const { rows } = await client.query("SELECT count(*)::int AS count FROM information_schema.tables WHERE table_name LIKE 'directus\\_%'");
+        return rows[0].count === 0;
+    }
+    finally {
+        await client.end();
+    }
+}
+async function firstImport(flags) {
+    const db = await (0, env_1.resolveDbConfig)(flags);
+    if (!(await isDatabaseEmpty(db))) {
+        logger_1.logger.warn('The database is not empty, skipping the first import');
+        return;
+    }
+    await (0, apply_snapshot_1.applySQLSnapshot)(db);
+    const fileSync = await (0, env_1.resolveFileSync)(flags, 'pull');
+    if (fileSync) {
+        await (0, sync_files_1.syncFiles)(fileSync);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transfer.js","sourceRoot":"","sources":["../../../../src/cli/commands/save/transfer.ts"],"names":[],"mappings":"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","sourcesContent":["import * as pg from 'pg';\nimport { applySQLSnapshot } from './apply-snapshot';\nimport { checkUnsaved } from './check-unsaved';\nimport { DbConfig, DbFlags, resolveCurrentStorage, resolveDbConfig, resolveFileSync, resolveIntermediateStorage, StorageFlags } from './env';\nimport { saveSQLSnapshot } from './save-snapshot';\nimport { syncFiles } from './sync-files';\nimport { logger } from '../../logger';\n\ntype CheckFlags = { lastSave?: string | false; yes?: boolean };\n\nexport async function saveSqlSchema(flags: DbFlags & { cedar?: boolean }) {\n  await saveSQLSnapshot(await resolveDbConfig(flags), { cedar: flags.cedar });\n}\n\nexport async function applySqlSchema(flags: DbFlags) {\n  await applySQLSnapshot(await resolveDbConfig(flags));\n}\n\nexport async function pushFiles(flags: StorageFlags) {\n  await syncFiles({\n    origin: await resolveCurrentStorage(flags),\n    destination: await resolveIntermediateStorage(flags),\n  });\n}\n\nexport async function pullFiles(flags: StorageFlags) {\n  await syncFiles({\n    origin: await resolveIntermediateStorage(flags),\n    destination: await resolveCurrentStorage(flags),\n  });\n}\n\nexport async function checkUnsavedChanges(flags: DbFlags & CheckFlags) {\n  await checkUnsaved({ lastSave: flags.lastSave, yes: flags.yes ?? false, db: await resolveDbConfig(flags) });\n}\n\nexport async function save(flags: DbFlags & StorageFlags & { cedar?: boolean }) {\n  const db = await resolveDbConfig(flags);\n  const fileSync = await resolveFileSync(flags, 'push');\n\n  // after the snapshot, so that syncFiles reads the freshly dumped directus_files.csv\n  logger.info(`[1/2] Saving the SQL snapshot of ${describeDb(db)} into ./sql`);\n  await saveSQLSnapshot(db, { cedar: flags.cedar });\n  if (fileSync) {\n    logger.info(`[2/2] Pushing files to the intermediate storage (${fileSync.origin.driver} → ${fileSync.destination.driver})`);\n    await syncFiles(fileSync);\n  }\n  logger.info('Save completed');\n}\n\nexport async function applySchema(flags: DbFlags & StorageFlags & CheckFlags) {\n  const db = await resolveDbConfig(flags);\n  const fileSync = await resolveFileSync(flags, 'pull');\n\n  logger.info(`[1/3] Checking for unsaved changes on ${describeDb(db)}`);\n  await checkUnsaved({ lastSave: flags.lastSave, yes: flags.yes ?? false, db });\n  if (fileSync) {\n    logger.info(`[2/3] Pulling files from the intermediate storage (${fileSync.origin.driver} → ${fileSync.destination.driver})`);\n    await syncFiles(fileSync);\n  }\n  logger.info(`[3/3] Applying the SQL snapshot to ${describeDb(db)}`);\n  await applySQLSnapshot(db);\n  logger.info('Schema applied');\n}\n\nfunction describeDb(db: DbConfig) {\n  return `${db.database}@${db.host}`;\n}\n\nasync function isDatabaseEmpty(db: DbConfig) {\n  const client = new pg.Client({\n    user: db.user,\n    host: db.host,\n    password: db.pwd,\n    database: db.database,\n    ...(db.ssl ? { ssl: { rejectUnauthorized: false } } : {}),\n  });\n  await client.connect();\n  try {\n    const { rows } = await client.query(\n      \"SELECT count(*)::int AS count FROM information_schema.tables WHERE table_name LIKE 'directus\\\\_%'\",\n    );\n    return rows[0].count === 0;\n  } finally {\n    await client.end();\n  }\n}\n\nexport async function firstImport(flags: DbFlags & StorageFlags) {\n  const db = await resolveDbConfig(flags);\n  if (!(await isDatabaseEmpty(db))) {\n    logger.warn('The database is not empty, skipping the first import');\n    return;\n  }\n  await applySQLSnapshot(db);\n  const fileSync = await resolveFileSync(flags, 'pull');\n  if (fileSync) {\n    await syncFiles(fileSync);\n  }\n}\n"]}

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

@@ -7,3 +7,8 @@ export declare const readFirstLineOfFile: (filePath: string) => Promise<string>;
 export declare const readCsvFile: (filePath: string) => Promise<{
     [key: string]: string;
 }[]>;
+/**
+ * Write rows as CSV (inverse of {@link readCsvFile}): same comma + `""`
+ * escaping, columns in `header` order, trailing newline.
+ */
+export declare const writeCsvFile: (filePath: string, header: string[], rows: Record<string, string>[]) => Promise<void>;

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

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readCsvFile = exports.readFirstLineOfFile = exports.getStackTracePaths = exports.getBasicType = exports.testPath = exports.deepCopy = void 0;
+exports.writeCsvFile = exports.readCsvFile = exports.readFirstLineOfFile = exports.getStackTracePaths = exports.getBasicType = exports.testPath = exports.deepCopy = void 0;
 const fs = require("fs");
 const util_1 = require("util");
 const readFile = (0, util_1.promisify)(fs.readFile);
+const writeFile = (0, util_1.promisify)(fs.writeFile);
 const deepCopy = (src, dest) => {
     for (const key in src) {
         if (typeof src[key] !== 'object') {
@@ -107,8 +108,17 @@ const readCsvFile = async (filePath) => {
         .filter((line) => line); // Trim and remove empty lines;
     const firstLine = lines[0].split(',').map((key) => key.trim());
     const otherLines = lines.slice(1);
+    // This Regex matches commas that are NOT inside double quotes
+    const csvSplitRegex = /,(?=(?:(?:[^"]*"){2})*[^"]*$)/;
     for (const line of otherLines) {
-        const values = line.split(',');
+        const values = line.split(csvSplitRegex).map((val) => {
+            let trimmed = val.trim();
+            // Remove surrounding quotes and unescape double-double quotes ("")
+            if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+                trimmed = trimmed.slice(1, -1).replace(/""/g, '"');
+            }
+            return trimmed;
+        });
         const item = {};
         for (let i = 0; i < values.length; i++) {
             const key = firstLine[i];
@@ -120,4 +130,24 @@ const readCsvFile = async (filePath) => {
     return result;
 };
 exports.readCsvFile = readCsvFile;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../src/cli/commands/save/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport { promisify } from 'util';\n\nconst readFile = promisify(fs.readFile);\n\nexport const deepCopy = (src: Record<string, any>, dest: Record<string, any>) => {\n  for (const key in src) {\n    if (typeof src[key] !== 'object') {\n      //est une feuille\n      dest[key] = src[key];\n    } else {\n      if (!dest[key]) {\n        if (Array.isArray(src[key])) {\n          dest[key] = [];\n        } else {\n          dest[key] = {};\n        }\n      }\n      deepCopy(src[key], dest[key]);\n    }\n  }\n};\n\nexport const testPath = (obj: any, ...args: string[]) => {\n  for (const key of args) {\n    if (obj && obj[key] !== undefined) {\n      // false positive : https://semgrep.dev/r?q=javascript.lang.security.audit.prototype-pollution.prototype-pollution-loop.prototype-pollution-loop\n      // we are read-only here\n      obj = obj[key]; // nosemgrep\n    } else {\n      return;\n    }\n  }\n  return obj;\n};\n\nexport type BasicType =\n\t| 'string'\n\t| 'number'\n\t| 'bigint'\n\t| 'boolean'\n\t| 'symbol'\n\t| 'undefined'\n\t| 'object'\n\t| 'function'\n\t| 'array'\n\t| 'date'\n\t| 'buffer';\n\nexport const getBasicType = (object: any): BasicType => {\n  let currentType: BasicType = typeof object;\n  if (currentType === 'object') {\n    if (object instanceof Date) {\n      currentType = 'date';\n    }\n    if (Array.isArray(object)) {\n      currentType = 'array';\n    }\n    if (Buffer.isBuffer(object)) {\n      currentType = 'buffer';\n    }\n  }\n  return currentType;\n};\n\nexport const getStackTracePaths: () => string[] = () => {\n  /**\n     * The pattern of an error is :\n     * Error: this is a test to see stack traces!\n        at __decorate (/home/louis/webcapsule/app/app-api/src/actions/action-manager.ts:5:95)\n        at Object.<anonymous> (/home/louis/webcapsule/app/app-api/src/actions/action-manager.ts:601:27)\n        at Module._compile (node:internal/modules/cjs/loader:1105:14)\n     *\n     */\n  const error = new Error();\n  const stacks = error.stack!.split('\\n');\n  stacks.shift();\n  const result : string[] = [];\n  for (let i = 0; i < stacks.length; i++) {\n    const line = stacks[i];\n    const pattern = /at[^(]+(?:\\(([^)]+):[0-9]+:[0-9]+\\)|(.*))/;\n    result.push(pattern.exec(line)![1]);\n  }\n  return result;\n};\n\nexport const readFirstLineOfFile: (filePath: string) => Promise<string> = (\n  filePath: string,\n) => {\n  return new Promise<string>((resolve, reject) => {\n    const rs = fs.createReadStream(filePath);\n    let acc = '';\n    let pos = 0;\n    let index;\n    rs\n      .on('data', (chunk: string | Buffer) => {\n        acc += chunk;\n        index = chunk.indexOf('\\n');\n        if (index === -1) {\n          pos += chunk.length;\n        } else {\n          pos += index;\n          rs.close();\n        }\n      })\n      .on('close', () =>\n        resolve(acc.slice(acc.charCodeAt(0) === 0xfeff ? 1 : 0, pos)),\n      )\n      .on('error', (err: Error) => reject(err));\n  });\n};\n\nexport const readCsvFile: (filePath: string) => Promise<\n  {\n    [key: string]: string;\n  }[]\n> = async (filePath) => {\n  const result: { [key: string]: string }[] = [];\n  const fileContent = (await readFile(filePath)).toString();\n  const lines = fileContent\n    .split('\\n')\n    .map((line: string) => line.trim())\n    .filter((line: string) => line); // Trim and remove empty lines;\n  const firstLine = lines[0].split(',').map((key: string) => key.trim());\n  const otherLines = lines.slice(1);\n  for (const line of otherLines) {\n    const values = line.split(',');\n    const item: Record<string, string> = {};\n    for (let i = 0; i < values.length; i++) {\n      const key = firstLine[i];\n      const value = values[i];\n      item[key] = value;\n    }\n    result.push(item);\n  }\n  return result;\n};"]}
+const escapeCsvCell = (value) => {
+    if (!value)
+        return '';
+    if (value.includes('"') || value.includes(',') || value.includes('\n')) {
+        return `"${value.replace(/"/g, '""')}"`;
+    }
+    return value;
+};
+/**
+ * Write rows as CSV (inverse of {@link readCsvFile}): same comma + `""`
+ * escaping, columns in `header` order, trailing newline.
+ */
+const writeCsvFile = async (filePath, header, rows) => {
+    const lines = [header.join(',')];
+    for (const row of rows) {
+        lines.push(header.map((col) => escapeCsvCell(row[col])).join(','));
+    }
+    await writeFile(filePath, `${lines.join('\n')}\n`);
+};
+exports.writeCsvFile = writeCsvFile;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../src/cli/commands/save/utils.ts"],"names":[],"mappings":";;;AAAA,yBAAyB;AACzB,+BAAiC;AAEjC,MAAM,QAAQ,GAAG,IAAA,gBAAS,EAAC,EAAE,CAAC,QAAQ,CAAC,CAAC;AACxC,MAAM,SAAS,GAAG,IAAA,gBAAS,EAAC,EAAE,CAAC,SAAS,CAAC,CAAC;AAEnC,MAAM,QAAQ,GAAG,CAAC,GAAwB,EAAE,IAAyB,EAAE,EAAE;IAC9E,KAAK,MAAM,GAAG,IAAI,GAAG,EAAE,CAAC;QACtB,IAAI,OAAO,GAAG,CAAC,GAAG,CAAC,KAAK,QAAQ,EAAE,CAAC;YACjC,iBAAiB;YACjB,IAAI,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC;QACvB,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;gBACf,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;oBAC5B,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC;gBACjB,CAAC;qBAAM,CAAC;oBACN,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC;gBACjB,CAAC;YACH,CAAC;YACD,IAAA,gBAAQ,EAAC,GAAG,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;QAChC,CAAC;IACH,CAAC;AACH,CAAC,CAAC;AAhBW,QAAA,QAAQ,YAgBnB;AAEK,MAAM,QAAQ,GAAG,CAAC,GAAQ,EAAE,GAAG,IAAc,EAAE,EAAE;IACtD,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,IAAI,GAAG,IAAI,GAAG,CAAC,GAAG,CAAC,KAAK,SAAS,EAAE,CAAC;YAClC,gJAAgJ;YAChJ,wBAAwB;YACxB,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,YAAY;QAC9B,CAAC;aAAM,CAAC;YACN,OAAO;QACT,CAAC;IACH,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC,CAAC;AAXW,QAAA,QAAQ,YAWnB;AAeK,MAAM,YAAY,GAAG,CAAC,MAAW,EAAa,EAAE;IACrD,IAAI,WAAW,GAAc,OAAO,MAAM,CAAC;IAC3C,IAAI,WAAW,KAAK,QAAQ,EAAE,CAAC;QAC7B,IAAI,MAAM,YAAY,IAAI,EAAE,CAAC;YAC3B,WAAW,GAAG,MAAM,CAAC;QACvB,CAAC;QACD,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;YAC1B,WAAW,GAAG,OAAO,CAAC;QACxB,CAAC;QACD,IAAI,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;YAC5B,WAAW,GAAG,QAAQ,CAAC;QACzB,CAAC;IACH,CAAC;IACD,OAAO,WAAW,CAAC;AACrB,CAAC,CAAC;AAdW,QAAA,YAAY,gBAcvB;AAEK,MAAM,kBAAkB,GAAmB,GAAG,EAAE;IACrD;;;;;;;SAOK;IACL,MAAM,KAAK,GAAG,IAAI,KAAK,EAAE,CAAC;IAC1B,MAAM,MAAM,GAAG,KAAK,CAAC,KAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACxC,MAAM,CAAC,KAAK,EAAE,CAAC;IACf,MAAM,MAAM,GAAc,EAAE,CAAC;IAC7B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACvC,MAAM,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QACvB,MAAM,OAAO,GAAG,2CAA2C,CAAC;QAC5D,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAE,CAAC,CAAC,CAAC,CAAC,CAAC;IACtC,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AAnBW,QAAA,kBAAkB,sBAmB7B;AAEK,MAAM,mBAAmB,GAA0C,CACxE,QAAgB,EAChB,EAAE;IACF,OAAO,IAAI,OAAO,CAAS,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QAC7C,MAAM,EAAE,GAAG,EAAE,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC;QACzC,IAAI,GAAG,GAAG,EAAE,CAAC;QACb,IAAI,GAAG,GAAG,CAAC,CAAC;QACZ,IAAI,KAAK,CAAC;QACV,EAAE;aACC,EAAE,CAAC,MAAM,EAAE,CAAC,KAAsB,EAAE,EAAE;YACrC,GAAG,IAAI,KAAK,CAAC;YACb,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;YAC5B,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;gBACjB,GAAG,IAAI,KAAK,CAAC,MAAM,CAAC;YACtB,CAAC;iBAAM,CAAC;gBACN,GAAG,IAAI,KAAK,CAAC;gBACb,EAAE,CAAC,KAAK,EAAE,CAAC;YACb,CAAC;QACH,CAAC,CAAC;aACD,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,CAChB,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAC9D;aACA,EAAE,CAAC,OAAO,EAAE,CAAC,GAAU,EAAE,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;IAC9C,CAAC,CAAC,CAAC;AACL,CAAC,CAAC;AAxBW,QAAA,mBAAmB,uBAwB9B;AAEK,MAAM,WAAW,GAIpB,KAAK,EAAE,QAAQ,EAAE,EAAE;IACrB,MAAM,MAAM,GAAgC,EAAE,CAAC;IAC/C,MAAM,WAAW,GAAG,CAAC,MAAM,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC;IAC1D,MAAM,KAAK,GAAG,WAAW;SACtB,KAAK,CAAC,IAAI,CAAC;SACX,GAAG,CAAC,CAAC,IAAY,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;SAClC,MAAM,CAAC,CAAC,IAAY,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,+BAA+B;IAClE,MAAM,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAW,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC;IACvE,MAAM,UAAU,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAClC,8DAA8D;IAC9D,MAAM,aAAa,GAAG,+BAA+B,CAAC;IACtD,KAAK,MAAM,IAAI,IAAI,UAAU,EAAE,CAAC;QAC9B,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,GAAG,CAAC,CAAC,GAAW,EAAE,EAAE;YAC3D,IAAI,OAAO,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC;YACzB,mEAAmE;YACnE,IAAI,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;gBACrD,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;YACrD,CAAC;YACD,OAAO,OAAO,CAAC;QACjB,CAAC,CAAC,CAAC;QACH,MAAM,IAAI,GAA2B,EAAE,CAAC;QACxC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACvC,MAAM,GAAG,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;YACzB,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;YACxB,IAAI,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;QACpB,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACpB,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AAjCW,QAAA,WAAW,eAiCtB;AAEF,MAAM,aAAa,GAAG,CAAC,KAAc,EAAU,EAAE;IAC/C,IAAI,CAAC,KAAK;QAAE,OAAO,EAAE,CAAC;IACtB,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QACvE,OAAO,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC;IAC1C,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AAEF;;;GAGG;AACI,MAAM,YAAY,GAAG,KAAK,EAC/B,QAAgB,EAChB,MAAgB,EAChB,IAA8B,EACf,EAAE;IACjB,MAAM,KAAK,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;IACjC,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,aAAa,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;IACrE,CAAC;IACD,MAAM,SAAS,CAAC,QAAQ,EAAE,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACrD,CAAC,CAAC;AAVW,QAAA,YAAY,gBAUvB","sourcesContent":["import * as fs from 'fs';\nimport { promisify } from 'util';\n\nconst readFile = promisify(fs.readFile);\nconst writeFile = promisify(fs.writeFile);\n\nexport const deepCopy = (src: Record<string, any>, dest: Record<string, any>) => {\n  for (const key in src) {\n    if (typeof src[key] !== 'object') {\n      //est une feuille\n      dest[key] = src[key];\n    } else {\n      if (!dest[key]) {\n        if (Array.isArray(src[key])) {\n          dest[key] = [];\n        } else {\n          dest[key] = {};\n        }\n      }\n      deepCopy(src[key], dest[key]);\n    }\n  }\n};\n\nexport const testPath = (obj: any, ...args: string[]) => {\n  for (const key of args) {\n    if (obj && obj[key] !== undefined) {\n      // false positive : https://semgrep.dev/r?q=javascript.lang.security.audit.prototype-pollution.prototype-pollution-loop.prototype-pollution-loop\n      // we are read-only here\n      obj = obj[key]; // nosemgrep\n    } else {\n      return;\n    }\n  }\n  return obj;\n};\n\nexport type BasicType =\n\t| 'string'\n\t| 'number'\n\t| 'bigint'\n\t| 'boolean'\n\t| 'symbol'\n\t| 'undefined'\n\t| 'object'\n\t| 'function'\n\t| 'array'\n\t| 'date'\n\t| 'buffer';\n\nexport const getBasicType = (object: any): BasicType => {\n  let currentType: BasicType = typeof object;\n  if (currentType === 'object') {\n    if (object instanceof Date) {\n      currentType = 'date';\n    }\n    if (Array.isArray(object)) {\n      currentType = 'array';\n    }\n    if (Buffer.isBuffer(object)) {\n      currentType = 'buffer';\n    }\n  }\n  return currentType;\n};\n\nexport const getStackTracePaths: () => string[] = () => {\n  /**\n     * The pattern of an error is :\n     * Error: this is a test to see stack traces!\n        at __decorate (/home/louis/webcapsule/app/app-api/src/actions/action-manager.ts:5:95)\n        at Object.<anonymous> (/home/louis/webcapsule/app/app-api/src/actions/action-manager.ts:601:27)\n        at Module._compile (node:internal/modules/cjs/loader:1105:14)\n     *\n     */\n  const error = new Error();\n  const stacks = error.stack!.split('\\n');\n  stacks.shift();\n  const result : string[] = [];\n  for (let i = 0; i < stacks.length; i++) {\n    const line = stacks[i];\n    const pattern = /at[^(]+(?:\\(([^)]+):[0-9]+:[0-9]+\\)|(.*))/;\n    result.push(pattern.exec(line)![1]);\n  }\n  return result;\n};\n\nexport const readFirstLineOfFile: (filePath: string) => Promise<string> = (\n  filePath: string,\n) => {\n  return new Promise<string>((resolve, reject) => {\n    const rs = fs.createReadStream(filePath);\n    let acc = '';\n    let pos = 0;\n    let index;\n    rs\n      .on('data', (chunk: string | Buffer) => {\n        acc += chunk;\n        index = chunk.indexOf('\\n');\n        if (index === -1) {\n          pos += chunk.length;\n        } else {\n          pos += index;\n          rs.close();\n        }\n      })\n      .on('close', () =>\n        resolve(acc.slice(acc.charCodeAt(0) === 0xfeff ? 1 : 0, pos)),\n      )\n      .on('error', (err: Error) => reject(err));\n  });\n};\n\nexport const readCsvFile: (filePath: string) => Promise<\n  {\n    [key: string]: string;\n  }[]\n> = async (filePath) => {\n  const result: { [key: string]: string }[] = [];\n  const fileContent = (await readFile(filePath)).toString();\n  const lines = fileContent\n    .split('\\n')\n    .map((line: string) => line.trim())\n    .filter((line: string) => line); // Trim and remove empty lines;\n  const firstLine = lines[0].split(',').map((key: string) => key.trim());\n  const otherLines = lines.slice(1);\n  // This Regex matches commas that are NOT inside double quotes\n  const csvSplitRegex = /,(?=(?:(?:[^\"]*\"){2})*[^\"]*$)/;\n  for (const line of otherLines) {\n    const values = line.split(csvSplitRegex).map((val: string) => {\n      let trimmed = val.trim();\n      // Remove surrounding quotes and unescape double-double quotes (\"\")\n      if (trimmed.startsWith('\"') && trimmed.endsWith('\"')) {\n        trimmed = trimmed.slice(1, -1).replace(/\"\"/g, '\"');\n      }\n      return trimmed;\n    });\n    const item: Record<string, string> = {};\n    for (let i = 0; i < values.length; i++) {\n      const key = firstLine[i];\n      const value = values[i];\n      item[key] = value;\n    }\n    result.push(item);\n  }\n  return result;\n};\n\nconst escapeCsvCell = (value?: string): string => {\n  if (!value) return '';\n  if (value.includes('\"') || value.includes(',') || value.includes('\\n')) {\n    return `\"${value.replace(/\"/g, '\"\"')}\"`;\n  }\n  return value;\n};\n\n/**\n * Write rows as CSV (inverse of {@link readCsvFile}): same comma + `\"\"`\n * escaping, columns in `header` order, trailing newline.\n */\nexport const writeCsvFile = async (\n  filePath: string,\n  header: string[],\n  rows: Record<string, string>[],\n): Promise<void> => {\n  const lines = [header.join(',')];\n  for (const row of rows) {\n    lines.push(header.map((col) => escapeCsvCell(row[col])).join(','));\n  }\n  await writeFile(filePath, `${lines.join('\\n')}\\n`);\n};"]}

package/lib/cli/commands/sync.js

@@ -1,13 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sync = sync;
+const logger_1 = require("../logger");
 async function sync(options) {
     if (options.dryRun) {
-        console.log('Dry run — showing what would be synced...');
+        logger_1.logger.info('Dry run — showing what would be synced...');
     }
     else {
-        console.log('Syncing Directus schema and extensions...');
+        logger_1.logger.info('Syncing d9 schema and extensions...');
     }
     // TODO: implement
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3luYy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jbGkvY29tbWFuZHMvc3luYy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUlBLG9CQU9DO0FBUE0sS0FBSyxVQUFVLElBQUksQ0FBQyxPQUFvQjtJQUM3QyxJQUFJLE9BQU8sQ0FBQyxNQUFNLEVBQUUsQ0FBQztRQUNuQixPQUFPLENBQUMsR0FBRyxDQUFDLDJDQUEyQyxDQUFDLENBQUM7SUFDM0QsQ0FBQztTQUFNLENBQUM7UUFDTixPQUFPLENBQUMsR0FBRyxDQUFDLDJDQUEyQyxDQUFDLENBQUM7SUFDM0QsQ0FBQztJQUNELGtCQUFrQjtBQUNwQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW50ZXJmYWNlIFN5bmNPcHRpb25zIHtcbiAgZHJ5UnVuPzogYm9vbGVhbjtcbn1cblxuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIHN5bmMob3B0aW9uczogU3luY09wdGlvbnMpIHtcbiAgaWYgKG9wdGlvbnMuZHJ5UnVuKSB7XG4gICAgY29uc29sZS5sb2coJ0RyeSBydW4g4oCUIHNob3dpbmcgd2hhdCB3b3VsZCBiZSBzeW5jZWQuLi4nKTtcbiAgfSBlbHNlIHtcbiAgICBjb25zb2xlLmxvZygnU3luY2luZyBEaXJlY3R1cyBzY2hlbWEgYW5kIGV4dGVuc2lvbnMuLi4nKTtcbiAgfVxuICAvLyBUT0RPOiBpbXBsZW1lbnRcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3luYy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jbGkvY29tbWFuZHMvc3luYy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQU1BLG9CQU9DO0FBYkQsc0NBQW1DO0FBTTVCLEtBQUssVUFBVSxJQUFJLENBQUMsT0FBb0I7SUFDN0MsSUFBSSxPQUFPLENBQUMsTUFBTSxFQUFFLENBQUM7UUFDbkIsZUFBTSxDQUFDLElBQUksQ0FBQywyQ0FBMkMsQ0FBQyxDQUFDO0lBQzNELENBQUM7U0FBTSxDQUFDO1FBQ04sZUFBTSxDQUFDLElBQUksQ0FBQyxxQ0FBcUMsQ0FBQyxDQUFDO0lBQ3JELENBQUM7SUFDRCxrQkFBa0I7QUFDcEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGxvZ2dlciB9IGZyb20gJy4uL2xvZ2dlcic7XG5cbmludGVyZmFjZSBTeW5jT3B0aW9ucyB7XG4gIGRyeVJ1bj86IGJvb2xlYW47XG59XG5cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBzeW5jKG9wdGlvbnM6IFN5bmNPcHRpb25zKSB7XG4gIGlmIChvcHRpb25zLmRyeVJ1bikge1xuICAgIGxvZ2dlci5pbmZvKCdEcnkgcnVuIOKAlCBzaG93aW5nIHdoYXQgd291bGQgYmUgc3luY2VkLi4uJyk7XG4gIH0gZWxzZSB7XG4gICAgbG9nZ2VyLmluZm8oJ1N5bmNpbmcgZDkgc2NoZW1hIGFuZCBleHRlbnNpb25zLi4uJyk7XG4gIH1cbiAgLy8gVE9ETzogaW1wbGVtZW50XG59XG4iXX0=