@wbce/projen-d9 0.0.27

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

@@ -0,0 +1,5 @@
+interface SyncOptions {
+    dryRun?: boolean;
+}
+export declare function sync(options: SyncOptions): Promise<void>;
+export {};

package/lib/cli/commands/sync.js

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

package/lib/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/lib/cli/index.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const init_1 = require("./commands/init");
+const apply_snapshot_1 = require("./commands/save/apply-snapshot");
+const sync_1 = require("./commands/sync");
+const program = new commander_1.Command();
+program
+    .name('wbce-directus')
+    .description('CLI tools for Directus project management')
+    .version('0.0.1');
+program
+    .command('init')
+    .description('Initialize a new Directus project')
+    .argument('[directory]', 'target directory', '.')
+    .action(init_1.init);
+program
+    .command('sync')
+    .description('Sync Directus schema and extensions')
+    .option('--dry-run', 'show what would be synced without making changes')
+    .action(sync_1.sync);
+program
+    .command('apply-snapshot')
+    .description('Apply a SQL snapshot to a Directus database')
+    .requiredOption('--host <host>', 'database host')
+    .requiredOption('--user <user>', 'database user')
+    .requiredOption('--password <password>', 'database password')
+    .requiredOption('--database <database>', 'database name')
+    .option('--ssl', 'enable SSL for database connections', false)
+    .action(async (opts) => {
+    await (0, apply_snapshot_1.applySQLSnapshot)({
+        host: opts.host,
+        user: opts.user,
+        pwd: opts.password,
+        database: opts.database,
+        ssl: opts.ssl,
+    });
+});
+void program.parseAsync().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});
+//# sourceMappingURL=data:application/json;base64,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

package/lib/index.d.ts

@@ -0,0 +1,59 @@
+import { AddExtensionOptions, D9ExtensionType, ExtensionFolder } from '@wbce/projen-d9-extension';
+import { GitHubConfig, GitHubConfigOptions, Dockerfile } from '@wbce/projen-shared';
+import { DockerCompose, DockerComposeService, javascript, Task, typescript } from 'projen';
+export interface PackageVersions {
+    readonly d9?: string;
+    /**
+     * The version of @ariga/atlas to use.
+     * @default "0.32.0"
+     */
+    readonly atlas?: string;
+}
+export interface D9ProjectOptions extends typescript.TypeScriptProjectOptions {
+    /**
+     * Options for the GitHub configuration.
+     * Set to false to disable GitHub config entirely.
+     * @default - default GitHubConfig with project defaults
+     */
+    readonly githubConfig?: GitHubConfigOptions | false;
+    /**
+     * The name of the extensions folder.
+     * @default "extension-packages"
+     */
+    readonly extensionsFolderName?: string;
+    readonly packageVersions?: PackageVersions;
+}
+export declare class D9Project extends javascript.NodeProject {
+    protected options: D9ProjectOptions;
+    readonly githubConfig?: GitHubConfig;
+    extensions: ExtensionFolder;
+    extensionFolder: string;
+    applySchemaTask: Task;
+    buildExtensionTask: Task;
+    dockerfile: Dockerfile;
+    dockerComposeFile: DockerCompose;
+    directusService: DockerComposeService;
+    databaseService: DockerComposeService;
+    cacheService: DockerComposeService;
+    constructor(options: D9ProjectOptions);
+    private addExtensionFolder;
+    addExtension(name: string, extensionTypes: D9ExtensionType[], options?: AddExtensionOptions): import("@wbce/projen-d9-extension").D9ExtensionProject;
+    private addFirstRunTask;
+    private addCreateAdminUserTask;
+    private addRunTask;
+    private addApplySchemaTask;
+    private addBuildExtensionTask;
+    private addDockerCompose;
+    private addSaveBranchWorkflow;
+    private addDockerfile;
+}
+/**
+ * @deprecated Use {@link D9ProjectOptions} instead. The package was renamed to `@wbce/projen-d9` to reflect that it targets the d9 fork, not upstream Directus.
+ */
+export interface DirectusProjectOptions extends D9ProjectOptions {
+}
+/**
+ * @deprecated Use {@link D9Project} instead. The package was renamed to `@wbce/projen-d9` to reflect that it targets the d9 fork, not upstream Directus.
+ */
+export declare class DirectusProject extends D9Project {
+}

package/lib/index.js

@@ -0,0 +1,322 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DirectusProject = exports.D9Project = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const projen_d9_extension_1 = require("@wbce/projen-d9-extension");
+const projen_shared_1 = require("@wbce/projen-shared");
+const projen_1 = require("projen");
+const workflows_model_1 = require("projen/lib/github/workflows-model");
+const javascript_1 = require("projen/lib/javascript");
+class D9Project extends projen_1.javascript.NodeProject {
+    constructor(options) {
+        const d9Version = options.packageVersions?.d9 || '12.0.1';
+        const atlasVersion = options.packageVersions?.atlas || '0.32.0';
+        super({
+            ...options,
+            packageManager: options.packageManager ?? projen_1.javascript.NodePackageManager.NPM,
+            github: false, // We use our own GitHubConfig instead
+            depsUpgrade: true,
+            depsUpgradeOptions: {
+                workflowOptions: {
+                    schedule: javascript_1.UpgradeDependenciesSchedule.DAILY,
+                },
+            },
+            licensed: false,
+            readme: options.readme ?? {
+                contents: [
+                    `# ${options.name}`,
+                    '',
+                    'A [d9](https://github.com/LaWebcapsule/d9) (Directus 9 fork) project scaffolded with [`@wbce/projen-d9`](https://www.npmjs.com/package/@wbce/projen-d9). Develop locally against Docker Compose, then build a Docker image to deploy anywhere.',
+                    '',
+                    '## Local development',
+                    '',
+                    '```sh',
+                    'npx projen install      # install dependencies',
+                    'npx projen first-run    # boot stack, create admin, start d9',
+                    '```',
+                    '',
+                    'Open http://localhost:8055 and sign in as `admin@example.com` / `totototo`. Extensions auto-reload (`EXTENSIONS_AUTO_RELOAD=true`).',
+                    '',
+                    '## Deploy',
+                    '',
+                    'A `Dockerfile` is included. Build and push the image for your target environment:',
+                    '',
+                    '```sh',
+                    'docker build -t <registry>/<image>:<tag> .',
+                    'docker push <registry>/<image>:<tag>',
+                    '```',
+                    '',
+                    'Configure the deployed instance with environment variables (database, cache, secrets) — see the d9 docs.',
+                    '',
+                    '## Common tasks',
+                    '',
+                    '| Task | Description |',
+                    '| --- | --- |',
+                    '| `npx projen run` | Start d9 (`docker compose up directus`) |',
+                    '| `npx projen build-extensions` | Install and build all extensions |',
+                    '| `npx projen create-an-admin` | Create the default admin user |',
+                    '',
+                    'See `.projen/tasks.json` for the full list.',
+                    '',
+                    '## Configuration',
+                    '',
+                    'Edit `.projenrc.js` and run `npx projen` to regenerate project files. Local environment overrides go in `.env.local`.',
+                    '',
+                    '## Extensions',
+                    '',
+                    'Extensions live under `./plugins/`. Add new ones in `.projenrc.js`:',
+                    '',
+                    '```js',
+                    "import { D9ExtensionType } from '@wbce/projen-d9-extension';",
+                    '',
+                    "project.addExtension('my-hook', [D9ExtensionType.HOOK]);",
+                    '```',
+                    '',
+                    'Then `npx projen && npx projen build-extensions`.',
+                ].join('\n'),
+            },
+            devDeps: [
+                '@wbce/projen-d9',
+                '@wbce/projen-d9-extension',
+                `@ariga/atlas@${atlasVersion}`,
+                ...(options.devDeps ?? []),
+            ],
+            deps: [`@wbce-d9/directus9@${d9Version}`],
+        });
+        this.options = options;
+        // No tsconfig means no tsc --build in compile
+        this.compileTask.reset();
+        this.addExtensionFolder();
+        this.addDockerCompose();
+        this.addApplySchemaTask();
+        this.addFirstRunTask();
+        this.addBuildExtensionTask();
+        this.addRunTask();
+        this.addDockerfile();
+        this.addCreateAdminUserTask();
+        new projen_1.AiInstructions(this, {
+            agents: [projen_1.AiAgent.CLAUDE],
+        });
+        if (options.githubConfig !== false) {
+            this.githubConfig = new projen_shared_1.GitHubConfig(this, options.githubConfig);
+            this.addSaveBranchWorkflow();
+        }
+        this.gitignore.addPatterns('uploads');
+        this.gitignore.addPatterns('**/.DS_Store');
+        this.gitignore.addPatterns('.env.local');
+        // Create an empty .env.local if it doesn't exist, so Docker doesn't mount a directory
+        new projen_1.SampleFile(this, '.env.local', { contents: '# Local environment overrides for Directus' });
+    }
+    addExtensionFolder() {
+        const folderName = this.options.extensionsFolderName ?? 'plugins';
+        this.extensions = new projen_d9_extension_1.ExtensionFolder({ parent: this, name: folderName });
+        this.extensionFolder = folderName;
+        this.gitignore.exclude('extensions/*');
+        this.gitignore.include('extensions/templates/');
+    }
+    addExtension(name, extensionTypes, options) {
+        return this.extensions.add(name, extensionTypes, options);
+    }
+    addFirstRunTask() {
+        const task = this.addTask('first-run', {
+            description: 'Initialize and start a fresh Directus instance',
+        });
+        const adminEmail = 'admin@example.com';
+        const userNotExistsCondition = `docker compose exec database psql -U directus -d directus -tAc "SELECT count(*) FROM directus_users WHERE email = '${adminEmail}'" | grep -q '^0$'`;
+        task.exec('docker compose up -d --wait database cache');
+        task.spawn(this.applySchemaTask);
+        task.exec(`ADMIN_ROLE_ID=$(docker compose exec database psql -U directus -d directus -tAc "SELECT id FROM directus_roles WHERE admin_access = true LIMIT 1") && docker compose run --rm directus npx directus users create --email ${adminEmail} --password totototo --role "$ADMIN_ROLE_ID"`, {
+            condition: userNotExistsCondition,
+        });
+        task.say(`User ${adminEmail} has been created with password totototo`, {
+            condition: userNotExistsCondition,
+        });
+        task.say(`User ${adminEmail} already exists, skipping creation`, {
+            condition: `! ${userNotExistsCondition}`,
+        });
+        task.exec('docker compose up directus');
+    }
+    addCreateAdminUserTask() {
+        const task = this.addTask('create-an-admin', {
+            description: 'Create an admin user',
+        });
+        const adminEmail = 'admin@example.com';
+        const userNotExistsCondition = `docker compose exec database psql -U directus -d directus -tAc "SELECT count(*) FROM directus_users WHERE email = '${adminEmail}'" | grep -q '^0$'`;
+        task.exec('docker compose up -d --wait database cache');
+        task.exec(`ADMIN_ROLE_ID=$(docker compose exec database psql -U directus -d directus -tAc "SELECT id FROM directus_roles WHERE admin_access = true LIMIT 1") && docker compose run --rm directus npx directus users create --email ${adminEmail} --password totototo --role "$ADMIN_ROLE_ID"`, {
+            condition: userNotExistsCondition,
+        });
+        task.say(`User ${adminEmail} has been created with password totototo`, {
+            condition: userNotExistsCondition,
+        });
+        task.say(`User ${adminEmail} already exists, skipping creation`, {
+            condition: `! ${userNotExistsCondition}`,
+        });
+    }
+    addRunTask() {
+        const task = this.addTask('run', {
+            description: 'start the Directus instance',
+        });
+        task.exec('docker compose up directus');
+    }
+    addApplySchemaTask() {
+        this.applySchemaTask = this.addTask('apply-schema', {
+            description: 'Apply SQL snapshot to the local Directus database',
+        });
+        this.applySchemaTask.exec('npx wbce-directus apply-snapshot --host localhost --user directus --password directus --database directus', {
+            condition: 'test -d ./sql',
+        });
+        this.applySchemaTask.exec('docker compose run --rm directus npx directus bootstrap', {
+            condition: 'test ! -d ./sql',
+        });
+    }
+    addBuildExtensionTask() {
+        this.buildExtensionTask = this.addTask('build-extensions', {
+            description: 'Build the directus extensions',
+        });
+        this.buildExtensionTask.exec(`cd ${this.extensionFolder} && pnpm install`);
+        this.buildExtensionTask.exec(`cd ${this.extensionFolder} && pnpm run --recursive build`);
+    }
+    addDockerCompose() {
+        const dc = new projen_1.DockerCompose(this);
+        this.databaseService = dc.addService('database', {
+            image: 'postgis/postgis:13-master',
+            volumes: [
+                projen_1.DockerCompose.namedVolume('pgdata', '/var/lib/postgresql/data'),
+            ],
+            ports: [
+                projen_1.DockerCompose.portMapping(5432, 5432),
+            ],
+            environment: {
+                POSTGRES_USER: 'directus',
+                POSTGRES_PASSWORD: 'directus',
+                POSTGRES_DB: 'directus',
+            },
+        });
+        this.cacheService = dc.addService('cache', {
+            image: 'redis:6',
+            volumes: [
+                projen_1.DockerCompose.namedVolume('redis_storage', '/data'),
+            ],
+            ports: [
+                projen_1.DockerCompose.portMapping(6379, 6379),
+            ],
+        });
+        this.directusService = dc.addService('directus', {
+            imageBuild: { context: '.' },
+            ports: [
+                projen_1.DockerCompose.portMapping(8055, 8055),
+            ],
+            volumes: [
+                projen_1.DockerCompose.bindVolume('./uploads', '/app/uploads'),
+                projen_1.DockerCompose.bindVolume('./extensions', '/app/extensions'),
+            ],
+            // dependsOn is set via addOverride below with condition: service_healthy
+            environment: {
+                KEY: 'some-random-key',
+                SECRET: 'another-random-key',
+                CONFIG_PATH: '.env.local',
+                DB_CLIENT: 'pg',
+                DB_HOST: 'database',
+                DB_PORT: '5432',
+                DB_DATABASE: 'directus',
+                DB_USER: 'directus',
+                DB_PASSWORD: 'directus',
+                CACHE_ENABLED: 'false',
+                CACHE_REDIS_HOST: 'cache',
+                CACHE_STATUS_HEADER: 'cache-hit',
+                CORS_ENABLED: 'true',
+                CORS_ORIGIN: 'true',
+                LOG_LEVEL: 'info',
+                ADMIN_EMAIL: 'admin@example.com',
+                ADMIN_PASSWORD: 'totototo',
+                EXTENSIONS_AUTO_RELOAD: 'true',
+                VALIDATE_ENTITIES_TOKENS_API_KEY: 'toto',
+                AWS_KMS_KEY_ID: 'tutu',
+            },
+            command: ['sh', '-c', 'npx directus start'],
+        });
+        this.directusService.addVolume(projen_1.DockerCompose.bindVolume('./.env.local', '/app/.env.local'));
+        // Add healthcheck for database (not natively supported by projen DockerCompose)
+        dc.file.addOverride('services.database.healthcheck', {
+            test: ['CMD', 'pg_isready', '--host=localhost', '--username=directus'],
+            interval: '10s',
+            timeout: '5s',
+            retries: 5,
+            start_interval: '5s',
+            start_period: '30s',
+        });
+        // Add healthcheck for cache
+        dc.file.addOverride('services.cache.healthcheck', {
+            test: ['CMD-SHELL', '[ $(redis-cli ping) = \'PONG\' ]'],
+            interval: '10s',
+            timeout: '5s',
+            retries: 5,
+            start_interval: '5s',
+            start_period: '30s',
+        });
+        // Override depends_on to use condition syntax
+        dc.file.addOverride('services.directus.depends_on', {
+            cache: { condition: 'service_healthy' },
+            database: { condition: 'service_healthy' },
+        });
+        this.dockerComposeFile = dc;
+        return dc;
+    }
+    addSaveBranchWorkflow() {
+        const workflow = this.githubConfig.addWorkflow('save-branch');
+        workflow.on({ push: { branches: ['*-save'] } });
+        workflow.addJob('create-pr', {
+            name: 'Create Pull Request',
+            runsOn: ['ubuntu-latest'],
+            permissions: {
+                contents: workflows_model_1.JobPermission.READ,
+                pullRequests: workflows_model_1.JobPermission.WRITE,
+            },
+            steps: [
+                { name: 'Checkout', uses: 'actions/checkout@v4' },
+                {
+                    name: 'Create Pull Request',
+                    run: 'gh pr create --title "Save: ${GITHUB_REF_NAME%-save}" --body "Auto-generated PR from branch \\`${GITHUB_REF_NAME%-save}\\`" --base "${GITHUB_REF_NAME%-save}" || echo "PR already exists"',
+                    env: { GH_TOKEN: '${{ secrets.GITHUB_TOKEN }}' },
+                },
+            ],
+        });
+    }
+    addDockerfile() {
+        this.dockerfile = new projen_shared_1.Dockerfile(this)
+            .from('node', '22-bookworm-slim')
+            .step('update-npm', 'Update npm to fix dependencies')
+            .run('npm install -g npm@11.8.0')
+            .step('install-pnpm', 'install pnpm')
+            .run('npm install -g pnpm@10.33.0')
+            .step('copy-package', 'Copy package.json and package-lock.json first to leverage Docker layer caching')
+            .copy('package*.json', '/app/')
+            .step('workdir', 'Set working directory')
+            .workdir('/app')
+            .step('install-deps', 'Install dependencies - without dev dependencies')
+            .run('NODE_ENV=production npm install')
+            .step('cleanup', 'Cleaning benchmarks folder in tedious module for security')
+            .run('rm -rf node_modules/tedious/benchmarks')
+            .step('copy-source', 'Copy the rest of the application code')
+            .copy('.', '.')
+            .step('build-extension', 'build extensions')
+            .run('npx projen build-extensions')
+            .step('start', 'Start Directus server')
+            .cmdExec(['npx', 'directus', 'start']);
+        return this.dockerfile;
+    }
+}
+exports.D9Project = D9Project;
+_a = JSII_RTTI_SYMBOL_1;
+D9Project[_a] = { fqn: "@wbce/projen-d9.D9Project", version: "0.0.25" };
+/**
+ * @deprecated Use {@link D9Project} instead. The package was renamed to `@wbce/projen-d9` to reflect that it targets the d9 fork, not upstream Directus.
+ */
+class DirectusProject extends D9Project {
+}
+exports.DirectusProject = DirectusProject;
+_b = JSII_RTTI_SYMBOL_1;
+DirectusProject[_b] = { fqn: "@wbce/projen-d9.DirectusProject", version: "0.0.25" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["import { AddExtensionOptions, D9ExtensionType, ExtensionFolder } from '@wbce/projen-d9-extension';\nimport { GitHubConfig, GitHubConfigOptions, Dockerfile } from '@wbce/projen-shared';\nimport { AiAgent, AiInstructions, DockerCompose, DockerComposeService, javascript, SampleFile, Task, typescript } from 'projen';\nimport { JobPermission } from 'projen/lib/github/workflows-model';\nimport { UpgradeDependenciesSchedule } from 'projen/lib/javascript';\n\nexport interface PackageVersions {\n  readonly d9?: string;\n  /**\n   * The version of @ariga/atlas to use.\n   * @default \"0.32.0\"\n   */\n  readonly atlas?: string;\n}\n\n\nexport interface D9ProjectOptions extends typescript.TypeScriptProjectOptions {\n  /**\n   * Options for the GitHub configuration.\n   * Set to false to disable GitHub config entirely.\n   * @default - default GitHubConfig with project defaults\n   */\n  readonly githubConfig?: GitHubConfigOptions | false;\n\n  /**\n   * The name of the extensions folder.\n   * @default \"extension-packages\"\n   */\n  readonly extensionsFolderName?: string;\n  readonly packageVersions?: PackageVersions;\n}\n\nexport class D9Project extends javascript.NodeProject {\n\n  public readonly githubConfig?: GitHubConfig;\n  public extensions!: ExtensionFolder;\n  public extensionFolder!: string;\n  public applySchemaTask!: Task;\n  public buildExtensionTask!: Task;\n  public dockerfile!: Dockerfile;\n  public dockerComposeFile!: DockerCompose;\n  public directusService!: DockerComposeService;\n  public databaseService!: DockerComposeService;\n  public cacheService!: DockerComposeService;\n\n  constructor(protected options: D9ProjectOptions) {\n    const d9Version = options.packageVersions?.d9 || '12.0.1';\n    const atlasVersion = options.packageVersions?.atlas || '0.32.0';\n    super({\n      ...options,\n      packageManager: options.packageManager ?? javascript.NodePackageManager.NPM,\n      github: false, // We use our own GitHubConfig instead\n      depsUpgrade: true,\n      depsUpgradeOptions: {\n        workflowOptions: {\n          schedule: UpgradeDependenciesSchedule.DAILY,\n        },\n      },\n      licensed: false,\n      readme: options.readme ?? {\n        contents: [\n          `# ${options.name}`,\n          '',\n          'A [d9](https://github.com/LaWebcapsule/d9) (Directus 9 fork) project scaffolded with [`@wbce/projen-d9`](https://www.npmjs.com/package/@wbce/projen-d9). Develop locally against Docker Compose, then build a Docker image to deploy anywhere.',\n          '',\n          '## Local development',\n          '',\n          '```sh',\n          'npx projen install      # install dependencies',\n          'npx projen first-run    # boot stack, create admin, start d9',\n          '```',\n          '',\n          'Open http://localhost:8055 and sign in as `admin@example.com` / `totototo`. Extensions auto-reload (`EXTENSIONS_AUTO_RELOAD=true`).',\n          '',\n          '## Deploy',\n          '',\n          'A `Dockerfile` is included. Build and push the image for your target environment:',\n          '',\n          '```sh',\n          'docker build -t <registry>/<image>:<tag> .',\n          'docker push <registry>/<image>:<tag>',\n          '```',\n          '',\n          'Configure the deployed instance with environment variables (database, cache, secrets) — see the d9 docs.',\n          '',\n          '## Common tasks',\n          '',\n          '| Task | Description |',\n          '| --- | --- |',\n          '| `npx projen run` | Start d9 (`docker compose up directus`) |',\n          '| `npx projen build-extensions` | Install and build all extensions |',\n          '| `npx projen create-an-admin` | Create the default admin user |',\n          '',\n          'See `.projen/tasks.json` for the full list.',\n          '',\n          '## Configuration',\n          '',\n          'Edit `.projenrc.js` and run `npx projen` to regenerate project files. Local environment overrides go in `.env.local`.',\n          '',\n          '## Extensions',\n          '',\n          'Extensions live under `./plugins/`. Add new ones in `.projenrc.js`:',\n          '',\n          '```js',\n          \"import { D9ExtensionType } from '@wbce/projen-d9-extension';\",\n          '',\n          \"project.addExtension('my-hook', [D9ExtensionType.HOOK]);\",\n          '```',\n          '',\n          'Then `npx projen && npx projen build-extensions`.',\n        ].join('\\n'),\n      },\n      devDeps: [\n        '@wbce/projen-d9',\n        '@wbce/projen-d9-extension',\n        `@ariga/atlas@${atlasVersion}`,\n        ...(options.devDeps ?? []),\n      ],\n      deps: [`@wbce-d9/directus9@${d9Version}`],\n    });\n\n    // No tsconfig means no tsc --build in compile\n    this.compileTask.reset();\n\n    this.addExtensionFolder();\n    this.addDockerCompose();\n    this.addApplySchemaTask();\n    this.addFirstRunTask();\n    this.addBuildExtensionTask();\n    this.addRunTask();\n    this.addDockerfile();\n    this.addCreateAdminUserTask();\n\n    new AiInstructions(this, {\n      agents: [AiAgent.CLAUDE],\n    });\n\n    if (options.githubConfig !== false) {\n      this.githubConfig = new GitHubConfig(this, options.githubConfig);\n      this.addSaveBranchWorkflow();\n    }\n    this.gitignore.addPatterns('uploads');\n    this.gitignore.addPatterns('**/.DS_Store');\n    this.gitignore.addPatterns('.env.local');\n\n    // Create an empty .env.local if it doesn't exist, so Docker doesn't mount a directory\n    new SampleFile(this, '.env.local', { contents: '# Local environment overrides for Directus' });\n  }\n\n  private addExtensionFolder() {\n    const folderName = this.options.extensionsFolderName ?? 'plugins';\n    this.extensions = new ExtensionFolder({ parent: this, name: folderName });\n    this.extensionFolder = folderName;\n    this.gitignore.exclude('extensions/*');\n    this.gitignore.include('extensions/templates/');\n  }\n\n  public addExtension(name: string, extensionTypes: D9ExtensionType[], options?: AddExtensionOptions ) {\n    return this.extensions.add(name, extensionTypes, options);\n  }\n\n  private addFirstRunTask() {\n    const task = this.addTask('first-run', {\n      description: 'Initialize and start a fresh Directus instance',\n    });\n    const adminEmail = 'admin@example.com';\n    const userNotExistsCondition = `docker compose exec database psql -U directus -d directus -tAc \"SELECT count(*) FROM directus_users WHERE email = '${adminEmail}'\" | grep -q '^0$'`;\n    task.exec('docker compose up -d --wait database cache');\n    task.spawn(this.applySchemaTask);\n    task.exec(`ADMIN_ROLE_ID=$(docker compose exec database psql -U directus -d directus -tAc \"SELECT id FROM directus_roles WHERE admin_access = true LIMIT 1\") && docker compose run --rm directus npx directus users create --email ${adminEmail} --password totototo --role \"$ADMIN_ROLE_ID\"`, {\n      condition: userNotExistsCondition,\n    });\n    task.say(`User ${adminEmail} has been created with password totototo`, {\n      condition: userNotExistsCondition,\n    });\n    task.say(`User ${adminEmail} already exists, skipping creation`, {\n      condition: `! ${userNotExistsCondition}`,\n    });\n    task.exec('docker compose up directus');\n  }\n\n  private addCreateAdminUserTask() {\n    const task = this.addTask('create-an-admin', {\n      description: 'Create an admin user',\n    });\n    const adminEmail = 'admin@example.com';\n    const userNotExistsCondition = `docker compose exec database psql -U directus -d directus -tAc \"SELECT count(*) FROM directus_users WHERE email = '${adminEmail}'\" | grep -q '^0$'`;\n    task.exec('docker compose up -d --wait database cache');\n    task.exec(`ADMIN_ROLE_ID=$(docker compose exec database psql -U directus -d directus -tAc \"SELECT id FROM directus_roles WHERE admin_access = true LIMIT 1\") && docker compose run --rm directus npx directus users create --email ${adminEmail} --password totototo --role \"$ADMIN_ROLE_ID\"`, {\n      condition: userNotExistsCondition,\n    });\n    task.say(`User ${adminEmail} has been created with password totototo`, {\n      condition: userNotExistsCondition,\n    });\n    task.say(`User ${adminEmail} already exists, skipping creation`, {\n      condition: `! ${userNotExistsCondition}`,\n    });\n  }\n\n  private addRunTask() {\n    const task = this.addTask('run', {\n      description: 'start the Directus instance',\n    });\n    task.exec('docker compose up directus');\n  }\n\n  private addApplySchemaTask() {\n    this.applySchemaTask = this.addTask('apply-schema', {\n      description: 'Apply SQL snapshot to the local Directus database',\n    });\n    this.applySchemaTask.exec('npx wbce-directus apply-snapshot --host localhost --user directus --password directus --database directus', {\n      condition: 'test -d ./sql',\n    });\n    this.applySchemaTask.exec('docker compose run --rm directus npx directus bootstrap', {\n      condition: 'test ! -d ./sql',\n    });\n  }\n\n  private addBuildExtensionTask() {\n    this.buildExtensionTask = this.addTask('build-extensions', {\n      description: 'Build the directus extensions',\n    });\n    this.buildExtensionTask.exec(`cd ${this.extensionFolder} && pnpm install`);\n    this.buildExtensionTask.exec(`cd ${this.extensionFolder} && pnpm run --recursive build`);\n  }\n\n\n  private addDockerCompose() {\n    const dc = new DockerCompose(this);\n\n    this.databaseService = dc.addService('database', {\n      image: 'postgis/postgis:13-master',\n      volumes: [\n        DockerCompose.namedVolume('pgdata', '/var/lib/postgresql/data'),\n      ],\n      ports: [\n        DockerCompose.portMapping(5432, 5432),\n      ],\n      environment: {\n        POSTGRES_USER: 'directus',\n        POSTGRES_PASSWORD: 'directus',\n        POSTGRES_DB: 'directus',\n      },\n    });\n\n    this.cacheService = dc.addService('cache', {\n      image: 'redis:6',\n      volumes: [\n        DockerCompose.namedVolume('redis_storage', '/data'),\n      ],\n      ports: [\n        DockerCompose.portMapping(6379, 6379),\n      ],\n    });\n\n    this.directusService = dc.addService('directus', {\n      imageBuild: { context: '.' },\n      ports: [\n        DockerCompose.portMapping(8055, 8055),\n      ],\n      volumes: [\n        DockerCompose.bindVolume('./uploads', '/app/uploads'),\n        DockerCompose.bindVolume('./extensions', '/app/extensions'),\n      ],\n      // dependsOn is set via addOverride below with condition: service_healthy\n      environment: {\n        KEY: 'some-random-key',\n        SECRET: 'another-random-key',\n        CONFIG_PATH: '.env.local',\n        DB_CLIENT: 'pg',\n        DB_HOST: 'database',\n        DB_PORT: '5432',\n        DB_DATABASE: 'directus',\n        DB_USER: 'directus',\n        DB_PASSWORD: 'directus',\n        CACHE_ENABLED: 'false',\n        CACHE_REDIS_HOST: 'cache',\n        CACHE_STATUS_HEADER: 'cache-hit',\n        CORS_ENABLED: 'true',\n        CORS_ORIGIN: 'true',\n        LOG_LEVEL: 'info',\n        ADMIN_EMAIL: 'admin@example.com',\n        ADMIN_PASSWORD: 'totototo',\n        EXTENSIONS_AUTO_RELOAD: 'true',\n        VALIDATE_ENTITIES_TOKENS_API_KEY: 'toto',\n        AWS_KMS_KEY_ID: 'tutu',\n      },\n      command: ['sh', '-c', 'npx directus start'],\n    });\n\n    this.directusService.addVolume(DockerCompose.bindVolume('./.env.local', '/app/.env.local'));\n\n    // Add healthcheck for database (not natively supported by projen DockerCompose)\n    dc.file.addOverride('services.database.healthcheck', {\n      test: ['CMD', 'pg_isready', '--host=localhost', '--username=directus'],\n      interval: '10s',\n      timeout: '5s',\n      retries: 5,\n      start_interval: '5s',\n      start_period: '30s',\n    });\n\n    // Add healthcheck for cache\n    dc.file.addOverride('services.cache.healthcheck', {\n      test: ['CMD-SHELL', '[ $(redis-cli ping) = \\'PONG\\' ]'],\n      interval: '10s',\n      timeout: '5s',\n      retries: 5,\n      start_interval: '5s',\n      start_period: '30s',\n    });\n\n    // Override depends_on to use condition syntax\n    dc.file.addOverride('services.directus.depends_on', {\n      cache: { condition: 'service_healthy' },\n      database: { condition: 'service_healthy' },\n    });\n\n    this.dockerComposeFile = dc;\n\n    return dc;\n  }\n\n  private addSaveBranchWorkflow() {\n    const workflow = this.githubConfig!.addWorkflow('save-branch');\n    workflow.on({ push: { branches: ['*-save'] } });\n    workflow.addJob('create-pr', {\n      name: 'Create Pull Request',\n      runsOn: ['ubuntu-latest'],\n      permissions: {\n        contents: JobPermission.READ,\n        pullRequests: JobPermission.WRITE,\n      },\n      steps: [\n        { name: 'Checkout', uses: 'actions/checkout@v4' },\n        {\n          name: 'Create Pull Request',\n          run: 'gh pr create --title \"Save: ${GITHUB_REF_NAME%-save}\" --body \"Auto-generated PR from branch \\\\`${GITHUB_REF_NAME%-save}\\\\`\" --base \"${GITHUB_REF_NAME%-save}\" || echo \"PR already exists\"',\n          env: { GH_TOKEN: '${{ secrets.GITHUB_TOKEN }}' },\n        },\n      ],\n    });\n  }\n\n  private addDockerfile() {\n    this.dockerfile = new Dockerfile(this)\n      .from('node', '22-bookworm-slim')\n      .step('update-npm', 'Update npm to fix dependencies')\n      .run('npm install -g npm@11.8.0')\n      .step('install-pnpm', 'install pnpm')\n      .run('npm install -g pnpm@10.33.0')\n      .step('copy-package', 'Copy package.json and package-lock.json first to leverage Docker layer caching')\n      .copy('package*.json', '/app/')\n      .step('workdir', 'Set working directory')\n      .workdir('/app')\n      .step('install-deps', 'Install dependencies - without dev dependencies')\n      .run('NODE_ENV=production npm install')\n      .step('cleanup', 'Cleaning benchmarks folder in tedious module for security')\n      .run('rm -rf node_modules/tedious/benchmarks')\n      .step('copy-source', 'Copy the rest of the application code')\n      .copy('.', '.')\n      .step('build-extension', 'build extensions')\n      .run('npx projen build-extensions')\n      .step('start', 'Start Directus server')\n      .cmdExec(['npx', 'directus', 'start']);\n    return this.dockerfile;\n  }\n\n}\n\n/**\n * @deprecated Use {@link D9ProjectOptions} instead. The package was renamed to `@wbce/projen-d9` to reflect that it targets the d9 fork, not upstream Directus.\n */\n// eslint-disable-next-line @typescript-eslint/no-empty-object-type\nexport interface DirectusProjectOptions extends D9ProjectOptions {}\n\n/**\n * @deprecated Use {@link D9Project} instead. The package was renamed to `@wbce/projen-d9` to reflect that it targets the d9 fork, not upstream Directus.\n */\nexport class DirectusProject extends D9Project {}\n"]}

package/node_modules/@types/node/LICENSE

@@ -0,0 +1,21 @@
+    MIT License
+
+    Copyright (c) Microsoft Corporation.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE

package/node_modules/@types/node/README.md

@@ -0,0 +1,16 @@
+# Installation
+> `npm install --save @types/node`
+
+# Summary
+This package contains type definitions for Node.js (https://nodejs.org/).
+
+# Details
+Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node/v12.
+
+### Additional Details
+ * Last updated: Tue, 07 Jun 2022 19:01:37 GMT
+ * Dependencies: none
+ * Global values: `Buffer`, `NodeJS`, `__dirname`, `__filename`, `clearImmediate`, `clearInterval`, `clearTimeout`, `console`, `exports`, `global`, `module`, `process`, `queueMicrotask`, `require`, `setImmediate`, `setInterval`, `setTimeout`
+
+# Credits
+These definitions were written by [Microsoft TypeScript](https://github.com/Microsoft), [DefinitelyTyped](https://github.com/DefinitelyTyped), [Alberto Schiabel](https://github.com/jkomyno), [Alvis HT Tang](https://github.com/alvis), [Andrew Makarov](https://github.com/r3nya), [Benjamin Toueg](https://github.com/btoueg), [Chigozirim C.](https://github.com/smac89), [David Junger](https://github.com/touffy), [Deividas Bakanas](https://github.com/DeividasBakanas), [Eugene Y. Q. Shen](https://github.com/eyqs), [Hannes Magnusson](https://github.com/Hannes-Magnusson-CK), [Hoàng Văn Khải](https://github.com/KSXGitHub), [Huw](https://github.com/hoo29), [Kelvin Jin](https://github.com/kjin), [Klaus Meinhardt](https://github.com/ajafff), [Lishude](https://github.com/islishude), [Mariusz Wiktorczyk](https://github.com/mwiktorczyk), [Mohsen Azimi](https://github.com/mohsen1), [Nicolas Even](https://github.com/n-e), [Nikita Galkin](https://github.com/galkin), [Parambir Singh](https://github.com/parambirs), [Sebastian Silbermann](https://github.com/eps1lon), [Simon Schick](https://github.com/SimonSchick), [Thomas den Hollander](https://github.com/ThomasdenH), [Wilco Bakker](https://github.com/WilcoBakker), [wwwy3y3](https://github.com/wwwy3y3), [Zane Hannan AU](https://github.com/ZaneHannanAU), [Samuel Ainsworth](https://github.com/samuela), [Kyle Uehlein](https://github.com/kuehlein), [Thanik Bhongbhibhat](https://github.com/bhongy), [Marcin Kopacz](https://github.com/chyzwar), [Trivikram Kamat](https://github.com/trivikr), [Junxiao Shi](https://github.com/yoursunny), [Ilia Baryshnikov](https://github.com/qwelias), and [ExE Boss](https://github.com/ExE-Boss).