@wbce/projen-d9 0.0.27

package/README.md

@@ -0,0 +1,82 @@
+# @wbce/projen-d9
+
+Projen template for [d9](https://github.com/LaWebcapsule/d9) projects (fork of Directus v9). Scaffolds a local development setup with Docker Compose (Postgres + Redis), extension management, and GitHub workflows — then produces a Docker image you can deploy to any environment.
+
+
+Companion package: [`@wbce/projen-d9-extension`](../directus-extension) for authoring extensions.
+
+## Bootstrap a new project
+
+```sh
+npx projen new --from @wbce/projen-d9
+```
+
+This creates a `.projenrc.js` and synthesizes the project.
+
+## Usage
+
+`.projenrc.js`:
+
+```js
+import { D9Project } from '@wbce/projen-d9';
+import { D9ExtensionType } from '@wbce/projen-d9-extension';
+
+const project = new D9Project({
+  name: 'my-d9',
+  defaultReleaseBranch: 'main',
+  eslintOptions: {
+    dirs: ['src', 'test'],
+    prettier: true,
+  },
+});
+
+// A shared package other extensions can depend on
+project.addExtension('shared', []);
+
+// A hook extension that depends on the shared package
+const myHook = project.addExtension('my-hook', [D9ExtensionType.HOOK]);
+myHook.addDeps('shared@workspace:');
+
+project.synth();
+```
+
+Then synth and start it:
+
+```sh
+npx projen
+npx projen first-run   # boot stack + create admin user
+npx projen run         # start d9 (port 8055)
+```
+
+The default admin user is `admin@example.com` / `totototo`.
+
+### Extension types
+
+`D9ExtensionType` values: `INTERFACE`, `DISPLAY`, `LAYOUT`, `MODULE`, `PANEL`, `ENDPOINT`, `HOOK`, `OPERATION`. Pass an empty array for a shared (non-extension) package.
+
+Extensions live under `./plugins/` (configurable via `extensionsFolderName`) and are built by the `build-extensions` task.
+
+## Generated tasks
+
+| Task | Description |
+| --- | --- |
+| `first-run` | Boot the stack, create admin, start d9 |
+| `run` | Start d9 (`docker compose up directus`) |
+| `build-extensions` | Install and build all extensions |
+| `create-an-admin` | Create the default admin user |
+
+## What gets generated
+
+- `docker-compose.yml` — d9, Postgres (PostGIS), Redis with healthchecks
+- `Dockerfile` — Node 22 + pnpm, builds extensions
+- `.env.local` — sample for local environment overrides
+- GitHub workflows via [`@wbce/projen-shared`](../shared) (set `githubConfig: false` to disable)
+
+## Options
+
+See [API.md](./API.md) for the full `D9ProjectOptions` reference. Highlights:
+
+- `extensionsFolderName` — folder for extension packages (default: `plugins`)
+- `packageVersions.d9` — version of `@wbce-d9/directus9` (default: `12.0.1`)
+- `packageVersions.atlas` — version of `@ariga/atlas` (default: `0.32.0`)
+- `githubConfig` — `GitHubConfigOptions` or `false` to disable

package/lib/cli/commands/init.d.ts

@@ -0,0 +1 @@
+export declare function init(directory: string): Promise<void>;

package/lib/cli/commands/init.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+async function init(directory) {
+    console.log(`Initializing Directus project in "${directory}"...`);
+    // TODO: implement
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5pdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jbGkvY29tbWFuZHMvaW5pdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLG9CQUdDO0FBSE0sS0FBSyxVQUFVLElBQUksQ0FBQyxTQUFpQjtJQUMxQyxPQUFPLENBQUMsR0FBRyxDQUFDLHFDQUFxQyxTQUFTLE1BQU0sQ0FBQyxDQUFDO0lBQ2xFLGtCQUFrQjtBQUNwQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGluaXQoZGlyZWN0b3J5OiBzdHJpbmcpIHtcbiAgY29uc29sZS5sb2coYEluaXRpYWxpemluZyBEaXJlY3R1cyBwcm9qZWN0IGluIFwiJHtkaXJlY3Rvcnl9XCIuLi5gKTtcbiAgLy8gVE9ETzogaW1wbGVtZW50XG59XG4iXX0=

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

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

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

@@ -0,0 +1,278 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applySQLSnapshot = applySQLSnapshot;
+const fs = require("fs");
+const stream_1 = require("stream");
+const util_1 = require("util");
+const pg = require("pg");
+const pg_copy_streams_1 = require("pg-copy-streams");
+const cli_1 = require("./cli");
+const utils_1 = require("./utils");
+const readdir = (0, util_1.promisify)(fs.readdir);
+const pipeline = (0, util_1.promisify)(stream_1.pipeline);
+async function applySQLSnapshot(dbConfig) {
+    let pgClient;
+    const connectionProps = {
+        user: dbConfig.user,
+        host: dbConfig.host,
+        password: dbConfig.pwd,
+        database: 'postgres',
+        ...(dbConfig.ssl ? { ssl: { rejectUnauthorized: false } } : {}),
+    };
+    //SCHEMA
+    //1. we create an empty db
+    //2. we populate with the schema
+    //3. we calculate the diff
+    pgClient = new pg.Client(connectionProps);
+    console.info('creating empty tmp database');
+    await pgClient.connect();
+    try {
+        await pgClient.query(`DROP DATABASE IF EXISTS ${dbConfig.database}_tmp_bis`);
+        await pgClient.query(`CREATE DATABASE ${dbConfig.database}_tmp_bis;`);
+    }
+    finally {
+        await pgClient.end();
+    }
+    connectionProps.database = `${dbConfig.database}_tmp_bis`;
+    pgClient = new pg.Client(connectionProps);
+    const endDbClient = new pg.Client({
+        ...connectionProps,
+        database: dbConfig.database,
+    });
+    await Promise.all([pgClient.connect(), endDbClient.connect()]);
+    let sqlMigration = '';
+    try {
+        console.info('populating with target schema');
+        //we manually install postgis and some extensions. We should do a dump of sql extensions but we are waiting for atlasgo to support this (time of writing : 19/03 - atlasgo released extensions support but not in the community version)
+        let extensionQuery = `
+            create extension if not exists postgis;
+            create extension if not exists fuzzystrmatch;
+            create extension if not exists postgis_tiger_geocoder ;
+            create extension if not exists postgis_raster ;
+            create extension if not exists postgis_topology ;
+            create extension if not exists address_standardizer ;
+        `;
+        //there is a problem with the dump in atlas : schema are created with CREATE and not create if not exits...
+        //so we insert extension creation after schema creation in order to avoid getting "schema already exists"
+        const sqlSchema = fs.readFileSync('./sql/schema.sql').toString();
+        const sqlSchemaWithExtension = sqlSchema
+            .replace('CREATE TABLE', `${extensionQuery}
+            CREATE TABLE`) //only first occurrence will be replaced
+            .replace(/CREATE SCHEMA IF NOT EXISTS/g, 'CREATE SCHEMA')
+            .replace(/CREATE SCHEMA/g, 'CREATE SCHEMA IF NOT EXISTS'); //ensure all create schema use "if not exists"
+        //if target database does not contain any directus tables we just need to populate the base schema.
+        const countTablesReq = `
+            SELECT COUNT(*) 
+            FROM information_schema.tables 
+            WHERE table_schema = 'public' AND table_name LIKE 'directus_%';
+        `;
+        const countTables = await endDbClient.query(countTablesReq);
+        if (Number(countTables.rows[0].count) === 0) {
+            //we drop the extension and reapply the schema with directus
+            console.info('Target database is empty ; populating it and exiting.');
+            //note that finally block will be executed, even if we return
+            await endDbClient.query(sqlSchemaWithExtension);
+        }
+        await pgClient.query(sqlSchemaWithExtension);
+    }
+    finally {
+        await pgClient.end();
+        await endDbClient.end();
+    }
+    //we calculate the diff
+    const migrationStream = new stream_1.Writable({
+        write: (chunk, _encoding, next) => {
+            sqlMigration += chunk.toString();
+            next();
+        },
+    });
+    console.info('calculating migration diff');
+    const cli = new cli_1.Cli();
+    await cli.command('npx', [
+        'atlas',
+        'schema',
+        'diff',
+        '--from',
+        `postgres://${dbConfig.user}:${dbConfig.pwd}@${dbConfig.host}/${dbConfig.database}?sslmode=${dbConfig.ssl ? 'require' : 'disable'}`,
+        '--to',
+        `postgres://${dbConfig.user}:${dbConfig.pwd}@${dbConfig.host}/${dbConfig.database}_tmp_bis?sslmode=${dbConfig.ssl ? 'require' : 'disable'}`,
+    ], {
+        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: migrationStream,
+    });
+    if (sqlMigration.includes('no changes to be made')) {
+        sqlMigration = '';
+    }
+    //we apply the diffs in schema and data in one transaction
+    const pgTmpClient = new pg.Client(connectionProps);
+    connectionProps.database = dbConfig.database;
+    pgClient = new pg.Client(connectionProps);
+    await Promise.all([pgClient.connect(), pgTmpClient.connect()]);
+    try {
+        await pgClient.query('BEGIN');
+        console.info('apply schema');
+        await pgClient.query(sqlMigration);
+        console.info('apply data');
+        //strategy to apply data :
+        //- remove the constraint
+        //- upsert the data
+        //- apply the constraint
+        //always be sure the ci user exists
+        await pgClient.query(`
+            INSERT INTO public.directus_users (id, first_name, last_name, email)
+            VALUES ('49bcde5d-90aa-4be8-ab10-f9ae1a07546f', 'CI', 'Webcapsule', 'ci@webcapsule.io')
+            ON CONFLICT DO NOTHING
+        `);
+        //for constraints see this :
+        //https://confluence.atlassian.com/kb/how-to-drop-and-recreate-the-database-constraints-on-postgresql-776812450.html
+        //we get all the constraints except the primary keys
+        console.info('remove the constraints on the table');
+        const constraints = await pgClient.query(`
+            SELECT nspname, relname, conname, pg_get_constraintdef(pg_constraint.oid)
+            FROM pg_constraint
+            INNER JOIN pg_class ON conrelid=pg_class.oid
+            INNER JOIN pg_namespace ON pg_namespace.oid=pg_class.relnamespace
+            WHERE NOT nspname = 'pg_catalog' AND NOT contype = 'p'
+            ORDER BY CASE WHEN contype='f' THEN 0 ELSE 1 END DESC,contype DESC,nspname DESC,relname DESC,conname DESC
+        `);
+        //remove the constraints
+        //the query above is both for adding or dropping order. For dropping, we need to reverse the order
+        for (let i = 0; i < constraints.rows.length; i++) {
+            const constraint = constraints.rows[constraints.rows.length - 1 - i];
+            await pgClient.query(`
+                ALTER TABLE ${constraint.nspname}."${constraint.relname}" DROP CONSTRAINT "${constraint.conname}"
+            `);
+        }
+        //replace data
+        console.info('replacing with data');
+        const csvFiles = await readdir('./sql/data');
+        console.log(csvFiles);
+        for (const file of csvFiles) {
+            if (file.endsWith('.csv')) {
+                const nonParsedTableName = file.slice(0, -4);
+                const originalTableName = pg.escapeIdentifier(nonParsedTableName);
+                let copyTableName = originalTableName;
+                let existingRowsCanCauseConflict = false;
+                if (['directus_files', 'directus_folders'].includes(nonParsedTableName)) {
+                    //delete all files and folders that are inside the "common" folder
+                    const commonFolderName = 'common';
+                    const folderKey = {
+                        directus_files: 'folder',
+                        directus_folders: 'parent',
+                    };
+                    await pgClient.query(` 
+                        WITH RECURSIVE folder_tree AS (
+                              -- Anchor: the "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
+                        )
+                        DELETE FROM public.${copyTableName} AS t
+                        WHERE t.${folderKey[nonParsedTableName]} IN (SELECT id FROM folder_tree);
+                        `);
+                    if (nonParsedTableName === 'directus_folders') {
+                        existingRowsCanCauseConflict = true;
+                    }
+                }
+                else {
+                    await pgClient.query(`DELETE FROM public.${copyTableName}`);
+                }
+                if (existingRowsCanCauseConflict) {
+                    //we will import data in a temporary table, then do the insert
+                    copyTableName = pg.escapeIdentifier(`${nonParsedTableName}_wbce_tmp`);
+                    await pgClient.query(`CREATE TEMP TABLE ${copyTableName} ON COMMIT DROP AS SELECT * FROM public.${originalTableName} WITH NO DATA`);
+                }
+                //read first line
+                let firstLine = await (0, utils_1.readFirstLineOfFile)(`./sql/data/${file}`);
+                firstLine = firstLine
+                    .split(',')
+                    .map((c) => `"${c}"`)
+                    .join(',');
+                const ingestStream = pgClient.query((0, pg_copy_streams_1.from)(`COPY ${copyTableName} (${firstLine})  FROM STDIN  DELIMITER ',' CSV HEADER`));
+                const sourceStream = fs.createReadStream(`./sql/data/${file}`);
+                ingestStream.on('close', () => {
+                    console.info(`ingested ${file}`);
+                });
+                console.info(`ingesting ${file}`);
+                await pipeline(sourceStream, ingestStream);
+                if (existingRowsCanCauseConflict) {
+                    await pgClient.query(`
+							DELETE FROM public.${originalTableName}
+							WHERE id IN (SELECT id FROM ${copyTableName});
+						`);
+                    await pgClient.query(`
+							INSERT INTO public.${originalTableName}
+							SELECT * FROM ${copyTableName};
+						`);
+                }
+            }
+        }
+        //reestablish the constraints
+        console.info('reestablish the constraints');
+        for (const constraint of constraints.rows) {
+            await pgClient.query(`
+                ALTER TABLE ${constraint.nspname}."${constraint.relname}" ADD CONSTRAINT "${constraint.conname}"  ${constraint.pg_get_constraintdef}
+            `);
+        }
+        //update the sequences
+        //when adding with COPY, all sequences are not up to date
+        //we need to find all sequences and then to find the max on the managed column and then to update the sequence
+        console.info('find sequences');
+        const sequences = await pgClient.query(`
+            SELECT n.nspname as "schema",
+                c.relname as "name",
+                CASE c.relkind WHEN 'r' THEN 'table' WHEN 'v' THEN 'view' WHEN 'm' THEN 'materialized view' WHEN 'i' THEN 'index' WHEN 'S' THEN 'sequence' WHEN 's' THEN 'special' WHEN 't' THEN 'TOAST table' WHEN 'f' THEN 'foreign table' WHEN 'p' THEN 'partitioned table' WHEN 'I' THEN 'partitioned index' END as "Type",
+                pg_catalog.pg_get_userbyid(c.relowner) as "Owner"
+            FROM pg_catalog.pg_class c
+                LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+            WHERE c.relkind IN ('S','')
+                AND n.nspname <> 'pg_catalog'
+                AND n.nspname !~ '^pg_toast'
+                AND n.nspname <> 'information_schema'
+            AND pg_catalog.pg_table_is_visible(c.oid)
+            ORDER BY 1,2;
+        `);
+        for (const seq of sequences.rows) {
+            console.info(`find column managed by ${seq.name}`);
+            const relation = await pgClient.query(`
+                SELECT d.refobjid::regclass as "table", a.attname as "field"
+                FROM   pg_depend    d
+                JOIN   pg_attribute a ON a.attrelid = d.refobjid
+                                    AND a.attnum   = d.refobjsubid
+                WHERE  d.objid = '${seq.schema}."${seq.name}"'::regclass
+                AND    d.refobjsubid > 0
+                AND    d.classid = 'pg_class'::regclass;
+            `);
+            console.info(`find max of ${relation.rows[0].table} ${relation.rows[0].field}`);
+            const max = await pgClient.query(`
+                SELECT MAX(${relation.rows[0].field})
+                FROM ${relation.rows[0].table}
+            `);
+            if (max.rows[0].max !== null) {
+                console.info('alter the sequence');
+                await pgClient.query(`alter sequence ${seq.schema}."${seq.name}" restart with ${max.rows[0].max + 1};`);
+            }
+        }
+        await pgClient.query('COMMIT');
+        console.log('success');
+    }
+    catch (e) {
+        await pgClient.query('ROLLBACK');
+        console.log('error');
+        throw e;
+    }
+    finally {
+        await pgClient.end();
+        await pgTmpClient.end();
+        console.log('end of the query');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"apply-snapshot.js","sourceRoot":"","sources":["../../../../src/cli/commands/save/apply-snapshot.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport { pipeline as streamPipeline, Writable } from 'stream';\nimport { promisify } from 'util';\nimport * as pg from 'pg';\nimport { from as copyFrom } from 'pg-copy-streams';\nimport { Cli } from './cli';\nimport { readFirstLineOfFile } from './utils';\n\nconst readdir = promisify(fs.readdir);\nconst pipeline = promisify(streamPipeline);\n\n\nexport async function applySQLSnapshot(dbConfig: {\n  host: string;\n  user: string;\n  pwd: string;\n  database: string;\n  ssl?: boolean;\n}): Promise<void> {\n  let pgClient: pg.Client;\n  const connectionProps: pg.ClientConfig = {\n    user: dbConfig.user,\n    host: dbConfig.host,\n    password: dbConfig.pwd,\n    database: 'postgres',\n    ...(dbConfig.ssl ? { ssl: { rejectUnauthorized: false } } : {}),\n  };\n    //SCHEMA\n    //1. we create an empty db\n    //2. we populate with the schema\n    //3. we calculate the diff\n  pgClient = new pg.Client(connectionProps);\n  console.info('creating empty tmp database');\n  await pgClient.connect();\n  try {\n    await pgClient.query(`DROP DATABASE IF EXISTS ${dbConfig.database}_tmp_bis`);\n    await pgClient.query(`CREATE DATABASE ${dbConfig.database}_tmp_bis;`);\n  } finally {\n    await pgClient.end();\n  }\n  connectionProps.database = `${dbConfig.database}_tmp_bis`;\n  pgClient = new pg.Client(connectionProps);\n\n  const endDbClient = new pg.Client({\n    ...connectionProps,\n    database: dbConfig.database,\n  });\n\n  await Promise.all([pgClient.connect(), endDbClient.connect()]);\n\n  let sqlMigration = '';\n  try {\n    console.info('populating with target schema');\n    //we manually install postgis and some extensions. We should do a dump of sql extensions but we are waiting for atlasgo to support this (time of writing : 19/03 - atlasgo released extensions support but not in the community version)\n    let extensionQuery = `\n            create extension if not exists postgis;\n            create extension if not exists fuzzystrmatch;\n            create extension if not exists postgis_tiger_geocoder ;\n            create extension if not exists postgis_raster ;\n            create extension if not exists postgis_topology ;\n            create extension if not exists address_standardizer ;\n        `;\n    //there is a problem with the dump in atlas : schema are created with CREATE and not create if not exits...\n    //so we insert extension creation after schema creation in order to avoid getting \"schema already exists\"\n    const sqlSchema = fs.readFileSync('./sql/schema.sql').toString();\n    const sqlSchemaWithExtension = sqlSchema\n      .replace(\n        'CREATE TABLE',\n        `${extensionQuery}\n            CREATE TABLE`,\n      ) //only first occurrence will be replaced\n      .replace(/CREATE SCHEMA IF NOT EXISTS/g, 'CREATE SCHEMA')\n      .replace(/CREATE SCHEMA/g, 'CREATE SCHEMA IF NOT EXISTS'); //ensure all create schema use \"if not exists\"\n    //if target database does not contain any directus tables we just need to populate the base schema.\n    const countTablesReq = `\n            SELECT COUNT(*) \n            FROM information_schema.tables \n            WHERE table_schema = 'public' AND table_name LIKE 'directus_%';\n        `;\n    const countTables = await endDbClient.query(countTablesReq);\n    if (Number(countTables.rows[0].count) === 0) {\n      //we drop the extension and reapply the schema with directus\n      console.info('Target database is empty ; populating it and exiting.');\n      //note that finally block will be executed, even if we return\n      await endDbClient.query(sqlSchemaWithExtension);\n    }\n\n    await pgClient.query(sqlSchemaWithExtension);\n  } finally {\n    await pgClient.end();\n    await endDbClient.end();\n  }\n\n  //we calculate the diff\n  const migrationStream = new Writable({\n    write: (chunk, _encoding, next) => {\n      sqlMigration += chunk.toString();\n      next();\n    },\n  });\n  console.info('calculating migration diff');\n  const cli = new Cli();\n  await cli.command(\n    'npx',\n    [\n      'atlas',\n      'schema',\n      'diff',\n      '--from',\n      `postgres://${dbConfig.user}:${dbConfig.pwd}@${dbConfig.host}/${dbConfig.database}?sslmode=${dbConfig.ssl ? 'require' : 'disable'}`,\n      '--to',\n      `postgres://${dbConfig.user}:${dbConfig.pwd}@${dbConfig.host}/${dbConfig.database}_tmp_bis?sslmode=${dbConfig.ssl ? 'require' : 'disable'}`,\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: migrationStream,\n    },\n  );\n  if (sqlMigration.includes('no changes to be made')) {\n    sqlMigration = '';\n  }\n  //we apply the diffs in schema and data in one transaction\n  const pgTmpClient = new pg.Client(connectionProps);\n  connectionProps.database = dbConfig.database;\n  pgClient = new pg.Client(connectionProps);\n  await Promise.all([pgClient.connect(), pgTmpClient.connect()]);\n  try {\n    await pgClient.query('BEGIN');\n    console.info('apply schema');\n    await pgClient.query(sqlMigration);\n    console.info('apply data');\n    //strategy to apply data :\n    //- remove the constraint\n    //- upsert the data\n    //- apply the constraint\n\n    //always be sure the ci user exists\n    await pgClient.query(`\n            INSERT INTO public.directus_users (id, first_name, last_name, email)\n            VALUES ('49bcde5d-90aa-4be8-ab10-f9ae1a07546f', 'CI', 'Webcapsule', 'ci@webcapsule.io')\n            ON CONFLICT DO NOTHING\n        `);\n\n    //for constraints see this :\n    //https://confluence.atlassian.com/kb/how-to-drop-and-recreate-the-database-constraints-on-postgresql-776812450.html\n    //we get all the constraints except the primary keys\n    console.info('remove the constraints on the table');\n    const constraints = await pgClient.query(`\n            SELECT nspname, relname, conname, pg_get_constraintdef(pg_constraint.oid)\n            FROM pg_constraint\n            INNER JOIN pg_class ON conrelid=pg_class.oid\n            INNER JOIN pg_namespace ON pg_namespace.oid=pg_class.relnamespace\n            WHERE NOT nspname = 'pg_catalog' AND NOT contype = 'p'\n            ORDER BY CASE WHEN contype='f' THEN 0 ELSE 1 END DESC,contype DESC,nspname DESC,relname DESC,conname DESC\n        `);\n\n    //remove the constraints\n    //the query above is both for adding or dropping order. For dropping, we need to reverse the order\n    for (let i = 0; i < constraints.rows.length; i++) {\n      const constraint = constraints.rows[constraints.rows.length - 1 - i];\n      await pgClient.query(`\n                ALTER TABLE ${constraint.nspname}.\"${constraint.relname}\" DROP CONSTRAINT \"${constraint.conname}\"\n            `);\n    }\n\n    //replace data\n    console.info('replacing with data');\n    const csvFiles = await readdir('./sql/data');\n    console.log(csvFiles);\n    for (const file of csvFiles) {\n      if (file.endsWith('.csv')) {\n        const nonParsedTableName = file.slice(0, -4);\n        const originalTableName = pg.escapeIdentifier(nonParsedTableName);\n        let copyTableName = originalTableName;\n        let existingRowsCanCauseConflict = false;\n        if (['directus_files', 'directus_folders'].includes(nonParsedTableName)) {\n          //delete all files and folders that are inside the \"common\" folder\n          const commonFolderName = 'common';\n          const folderKey: Record<string, string> = {\n            directus_files: 'folder',\n            directus_folders: 'parent',\n          };\n          await pgClient.query(` \n                        WITH RECURSIVE folder_tree AS (\n                              -- Anchor: the \"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                        DELETE FROM public.${copyTableName} AS t\n                        WHERE t.${folderKey[nonParsedTableName]} IN (SELECT id FROM folder_tree);\n                        `);\n          if (nonParsedTableName === 'directus_folders') {\n            existingRowsCanCauseConflict = true;\n          }\n        } else {\n          await pgClient.query(`DELETE FROM public.${copyTableName}`);\n        }\n        if (existingRowsCanCauseConflict) {\n          //we will import data in a temporary table, then do the insert\n          copyTableName = pg.escapeIdentifier(`${nonParsedTableName}_wbce_tmp`);\n          await pgClient.query(\n            `CREATE TEMP TABLE ${copyTableName} ON COMMIT DROP AS SELECT * FROM public.${originalTableName} WITH NO DATA`,\n          );\n        }\n        //read first line\n        let firstLine = await readFirstLineOfFile(`./sql/data/${file}`);\n        firstLine = firstLine\n          .split(',')\n          .map((c) => `\"${c}\"`)\n          .join(',');\n        const ingestStream = pgClient.query(\n          copyFrom(\n            `COPY ${copyTableName} (${firstLine})  FROM STDIN  DELIMITER ',' CSV HEADER`,\n          ),\n        );\n        const sourceStream = fs.createReadStream(`./sql/data/${file}`);\n        ingestStream.on('close', () => {\n          console.info(`ingested ${file}`);\n        });\n        console.info(`ingesting ${file}`);\n\n        await pipeline(sourceStream, ingestStream);\n        if (existingRowsCanCauseConflict) {\n          await pgClient.query(`\n\t\t\t\t\t\t\tDELETE FROM public.${originalTableName}\n\t\t\t\t\t\t\tWHERE id IN (SELECT id FROM ${copyTableName});\n\t\t\t\t\t\t`);\n          await pgClient.query(`\n\t\t\t\t\t\t\tINSERT INTO public.${originalTableName}\n\t\t\t\t\t\t\tSELECT * FROM ${copyTableName};\n\t\t\t\t\t\t`);\n        }\n      }\n    }\n\n    //reestablish the constraints\n    console.info('reestablish the constraints');\n    for (const constraint of constraints.rows) {\n      await pgClient.query(`\n                ALTER TABLE ${constraint.nspname}.\"${constraint.relname}\" ADD CONSTRAINT \"${constraint.conname}\"  ${constraint.pg_get_constraintdef}\n            `);\n    }\n\n    //update the sequences\n    //when adding with COPY, all sequences are not up to date\n    //we need to find all sequences and then to find the max on the managed column and then to update the sequence\n\n    console.info('find sequences');\n    const sequences = await pgClient.query(`\n            SELECT n.nspname as \"schema\",\n                c.relname as \"name\",\n                CASE c.relkind WHEN 'r' THEN 'table' WHEN 'v' THEN 'view' WHEN 'm' THEN 'materialized view' WHEN 'i' THEN 'index' WHEN 'S' THEN 'sequence' WHEN 's' THEN 'special' WHEN 't' THEN 'TOAST table' WHEN 'f' THEN 'foreign table' WHEN 'p' THEN 'partitioned table' WHEN 'I' THEN 'partitioned index' END as \"Type\",\n                pg_catalog.pg_get_userbyid(c.relowner) as \"Owner\"\n            FROM pg_catalog.pg_class c\n                LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace\n            WHERE c.relkind IN ('S','')\n                AND n.nspname <> 'pg_catalog'\n                AND n.nspname !~ '^pg_toast'\n                AND n.nspname <> 'information_schema'\n            AND pg_catalog.pg_table_is_visible(c.oid)\n            ORDER BY 1,2;\n        `);\n\n    for (const seq of sequences.rows) {\n      console.info(`find column managed by ${seq.name}`);\n      const relation = await pgClient.query(`\n                SELECT d.refobjid::regclass as \"table\", a.attname as \"field\"\n                FROM   pg_depend    d\n                JOIN   pg_attribute a ON a.attrelid = d.refobjid\n                                    AND a.attnum   = d.refobjsubid\n                WHERE  d.objid = '${seq.schema}.\"${seq.name}\"'::regclass\n                AND    d.refobjsubid > 0\n                AND    d.classid = 'pg_class'::regclass;\n            `);\n      console.info(\n        `find max of ${relation.rows[0].table} ${relation.rows[0].field}`,\n      );\n      const max = await pgClient.query(`\n                SELECT MAX(${relation.rows[0].field})\n                FROM ${relation.rows[0].table}\n            `);\n\n      if (max.rows[0].max !== null) {\n        console.info('alter the sequence');\n        await pgClient.query(\n          `alter sequence ${seq.schema}.\"${seq.name}\" restart with ${max.rows[0].max + 1};`,\n        );\n      }\n    }\n\n    await pgClient.query('COMMIT');\n    console.log('success');\n\n  } catch (e) {\n    await pgClient.query('ROLLBACK');\n    console.log('error');\n\n    throw e;\n  } finally {\n    await pgClient.end();\n    await pgTmpClient.end();\n    console.log('end of the query');\n  }\n}\n\n"]}

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

@@ -0,0 +1,8 @@
+import { SpawnOptionsWithoutStdio } from 'child_process';
+import { Writable } from 'stream';
+export declare class Cli {
+    command(command: string, args: string[], options?: SpawnOptionsWithoutStdio & {
+        stderr?: Writable;
+        stdout?: Writable;
+    }): Promise<void>;
+}

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cli = void 0;
+const child_process_1 = require("child_process");
+class Cli {
+    command(command, args, options = {}) {
+        return new Promise((resolve, reject) => {
+            const childProcess = (0, child_process_1.spawn)(command, args, { ...options });
+            let error;
+            childProcess.on('error', (err) => {
+                error = new Error();
+                error.message = String(err);
+            });
+            childProcess.stderr.pipe(options.stderr || process.stderr);
+            childProcess.stdout.pipe(options.stdout || process.stdout);
+            childProcess.on('close', (code) => {
+                if (error) {
+                    reject(error);
+                }
+                else if (code === 0) {
+                    resolve();
+                }
+                else {
+                    error = new Error();
+                    error.message = `Process ${command} exited with code ${code}`;
+                    reject(error);
+                }
+            });
+        });
+    }
+}
+exports.Cli = Cli;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJhZnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvY2xpL2NvbW1hbmRzL3NhdmUvZHJhZnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIiJdfQ==

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

@@ -0,0 +1,9 @@
+export declare const deepCopy: (src: Record<string, any>, dest: Record<string, any>) => void;
+export declare const testPath: (obj: any, ...args: string[]) => any;
+export type BasicType = 'string' | 'number' | 'bigint' | 'boolean' | 'symbol' | 'undefined' | 'object' | 'function' | 'array' | 'date' | 'buffer';
+export declare const getBasicType: (object: any) => BasicType;
+export declare const getStackTracePaths: () => string[];
+export declare const readFirstLineOfFile: (filePath: string) => Promise<string>;
+export declare const readCsvFile: (filePath: string) => Promise<{
+    [key: string]: string;
+}[]>;

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

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 deepCopy = (src, dest) => {
+    for (const key in src) {
+        if (typeof src[key] !== 'object') {
+            //est une feuille
+            dest[key] = src[key];
+        }
+        else {
+            if (!dest[key]) {
+                if (Array.isArray(src[key])) {
+                    dest[key] = [];
+                }
+                else {
+                    dest[key] = {};
+                }
+            }
+            (0, exports.deepCopy)(src[key], dest[key]);
+        }
+    }
+};
+exports.deepCopy = deepCopy;
+const testPath = (obj, ...args) => {
+    for (const key of args) {
+        if (obj && obj[key] !== undefined) {
+            // false positive : https://semgrep.dev/r?q=javascript.lang.security.audit.prototype-pollution.prototype-pollution-loop.prototype-pollution-loop
+            // we are read-only here
+            obj = obj[key]; // nosemgrep
+        }
+        else {
+            return;
+        }
+    }
+    return obj;
+};
+exports.testPath = testPath;
+const getBasicType = (object) => {
+    let currentType = typeof object;
+    if (currentType === 'object') {
+        if (object instanceof Date) {
+            currentType = 'date';
+        }
+        if (Array.isArray(object)) {
+            currentType = 'array';
+        }
+        if (Buffer.isBuffer(object)) {
+            currentType = 'buffer';
+        }
+    }
+    return currentType;
+};
+exports.getBasicType = getBasicType;
+const getStackTracePaths = () => {
+    /**
+       * The pattern of an error is :
+       * Error: this is a test to see stack traces!
+          at __decorate (/home/louis/webcapsule/app/app-api/src/actions/action-manager.ts:5:95)
+          at Object.<anonymous> (/home/louis/webcapsule/app/app-api/src/actions/action-manager.ts:601:27)
+          at Module._compile (node:internal/modules/cjs/loader:1105:14)
+       *
+       */
+    const error = new Error();
+    const stacks = error.stack.split('\n');
+    stacks.shift();
+    const result = [];
+    for (let i = 0; i < stacks.length; i++) {
+        const line = stacks[i];
+        const pattern = /at[^(]+(?:\(([^)]+):[0-9]+:[0-9]+\)|(.*))/;
+        result.push(pattern.exec(line)[1]);
+    }
+    return result;
+};
+exports.getStackTracePaths = getStackTracePaths;
+const readFirstLineOfFile = (filePath) => {
+    return new Promise((resolve, reject) => {
+        const rs = fs.createReadStream(filePath);
+        let acc = '';
+        let pos = 0;
+        let index;
+        rs
+            .on('data', (chunk) => {
+            acc += chunk;
+            index = chunk.indexOf('\n');
+            if (index === -1) {
+                pos += chunk.length;
+            }
+            else {
+                pos += index;
+                rs.close();
+            }
+        })
+            .on('close', () => resolve(acc.slice(acc.charCodeAt(0) === 0xfeff ? 1 : 0, pos)))
+            .on('error', (err) => reject(err));
+    });
+};
+exports.readFirstLineOfFile = readFirstLineOfFile;
+const readCsvFile = async (filePath) => {
+    const result = [];
+    const fileContent = (await readFile(filePath)).toString();
+    const lines = fileContent
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line); // Trim and remove empty lines;
+    const firstLine = lines[0].split(',').map((key) => key.trim());
+    const otherLines = lines.slice(1);
+    for (const line of otherLines) {
+        const values = line.split(',');
+        const item = {};
+        for (let i = 0; i < values.length; i++) {
+            const key = firstLine[i];
+            const value = values[i];
+            item[key] = value;
+        }
+        result.push(item);
+    }
+    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};"]}