@hiiretail/gcp-infra-generators 1.9.0 → 1.11.0

package/dist/generators/common-resources/firebase/README.md

@@ -0,0 +1,70 @@
+# Firebase Generator
+
+This generator scaffolds Firebase infrastructure configuration for use with Terragrunt and the [terraform-google-firebase](https://github.com/GoogleCloudPlatform/terraform-google-firebase) module (v0.2.3).
+
+## Generated Files
+
+Located at `infra/{env}/firebase/`:
+
+1. **firebase.yaml** - Platform configuration
+2. **terragrunt.hcl** - Firebase multi-platform app registration
+
+## File Architecture
+
+```text
+infra/
+  prod/firebase/
+    firebase.yaml
+    terragrunt.hcl
+  staging/firebase/
+    firebase.yaml
+    terragrunt.hcl
+```
+
+## firebase.yaml Format
+
+```yaml
+apps:
+  android:
+    package_name: "com.example.app"
+  ios:
+    bundle_id: "com.example.app"
+```
+
+- **android.package_name**: Android application ID in reverse-domain format
+- **ios.bundle_id**: iOS bundle identifier in reverse-domain format
+
+Either platform section can be removed to stop managing that platform. At least one must remain.
+
+## Apps Module Outputs (FCM Config Files)
+
+After `terragrunt apply`, the platform SDK config files are available as Terraform outputs:
+
+| Output           | Platform | File                                        |
+| ---------------- | -------- | ------------------------------------------- |
+| `android_config` | Android  | `google-services.json` (base64-encoded)     |
+| `apple_config`   | iOS      | `GoogleService-Info.plist` (base64-encoded) |
+
+Decode and save the files from `infra/{env}/firebase/`:
+
+```bash
+# Android
+terragrunt output -raw android_config | base64 --decode > google-services.json
+
+# iOS
+terragrunt output -raw apple_config | base64 --decode > GoogleService-Info.plist
+```
+
+## Terragrunt Configuration
+
+The `terragrunt.hcl` reads from the `firebase.yaml` in the same directory:
+
+```hcl
+locals {
+  config = yamldecode(file("${get_terragrunt_dir()}/firebase.yaml"))
+}
+```
+
+```bash
+terragrunt apply --terragrunt-working-dir infra/prod/firebase
+```

package/dist/generators/common-resources/firebase/generator.json

@@ -0,0 +1,4 @@
+{
+  "name": "Firebase",
+  "description": "Configure Firebase apps, authentication, and Firestore rules"
+}

package/dist/generators/common-resources/firebase/index.js

@@ -0,0 +1,102 @@
+const path = require('path');
+const chalk = require('chalk');
+const BaseGenerator = require('../../../src/BaseGenerator');
+const { required } = require('../../../src/validators');
+
+module.exports = class extends BaseGenerator {
+  prompting() {
+    const prompts = [
+      {
+        type: 'input',
+        name: 'appDisplayName',
+        message: 'App display name (shared across all platforms):',
+        validate: required,
+      },
+      {
+        type: 'checkbox',
+        name: 'platforms',
+        message: 'Which platforms do you want to register Firebase apps for?',
+        choices: [
+          { name: 'Android', value: 'android', checked: true },
+          { name: 'iOS', value: 'ios', checked: true },
+        ],
+        validate: (selected) =>
+          selected.length > 0 || 'Select at least one platform.',
+      },
+      {
+        when: (response) => response.platforms.includes('android'),
+        type: 'input',
+        name: 'androidPackageName',
+        message:
+          'Android package name - letters, digits, underscores, and dots only, no hyphens (e.g. com.example_app.checkout):',
+        validate: required,
+      },
+      {
+        when: (response) => response.platforms.includes('ios'),
+        type: 'input',
+        name: 'iosBundleId',
+        message:
+          'iOS bundle ID - letters, digits, hyphens, and dots only, no underscores (e.g. com.example-app.checkout):',
+        validate: required,
+      },
+    ];
+
+    return this.prompt(prompts).then((props) => {
+      this.answers = props;
+    });
+  }
+
+  writing() {
+    const {
+      appDisplayName,
+      platforms = [],
+      androidPackageName,
+      iosBundleId,
+    } = this.answers;
+
+    const yamlContext = {
+      appDisplayName,
+      platforms,
+      androidPackageName,
+      iosBundleId,
+    };
+
+    ['prod', 'staging'].forEach((env) => {
+      const firebaseDest = path.join('infra', env, 'firebase');
+
+      this.fs.copyTpl(
+        this.templatePath('firebase', 'firebase.yaml'),
+        this.destinationPath(firebaseDest, 'firebase.yaml'),
+        yamlContext,
+      );
+
+      this.fs.copy(
+        this.templatePath('firebase', 'terragrunt.hcl'),
+        this.destinationPath(firebaseDest, 'terragrunt.hcl'),
+      );
+    });
+  }
+
+  end() {
+    const header = chalk.green(
+      'Your Firebase configuration has been created. Review the generated files:',
+    );
+    let message = header;
+    let i = 1;
+
+    message += `\n${chalk.green(`${i++}.`)} ${chalk.cyan(path.join('firebase', 'firebase.yaml'))} - Shared Firebase configuration`;
+    message += `\n${chalk.green(`${i++}.`)} ${chalk.cyan(path.join('firebase', 'terragrunt.hcl'))} - Firebase apps module`;
+
+    message += chalk.yellow(
+      '\n\nAfter applying, retrieve the FCM config files from infra/{env}/firebase/:',
+    );
+    message += chalk.cyan(
+      '\n  terragrunt output -raw android_config | base64 --decode > google-services.json',
+    );
+    message += chalk.cyan(
+      '\n  terragrunt output -raw apple_config | base64 --decode > GoogleService-Info.plist',
+    );
+
+    this.log(`\n${message}\n`);
+  }
+};

package/dist/generators/common-resources/firebase/templates/firebase/apps/terragrunt.hcl

@@ -0,0 +1,38 @@
+# Terragrunt configuration for Firebase multi-platform application
+# https://github.com/GoogleCloudPlatform/terraform-google-firebase
+
+terraform {
+  source = "git::https://github.com/extenda/terraform-google-firebase//modules/firebase_multi_platform_application/apps?ref=feat/Add-wrapper-apps-around-multi-application-module"
+}
+
+include {
+  path = find_in_parent_folders("terragrunt_root.hcl")
+}
+
+generate "firebase_providers" {
+  path      = "firebase_providers.tf"
+  if_exists = "overwrite_terragrunt"
+  contents  = <<EOF
+provider "google" {
+  project               = var.project_id
+  billing_project       = var.project_id
+  user_project_override = true
+}
+
+provider "google-beta" {
+  project               = var.project_id
+  billing_project       = var.project_id
+  user_project_override = true
+}
+EOF
+}
+
+locals {
+  project_vars = read_terragrunt_config(find_in_parent_folders("project.hcl"))
+  config       = yamldecode(file("${get_terragrunt_dir()}/../firebase.yaml"))
+}
+
+inputs = {
+  project_id = local.project_vars.locals.project_id
+  apps       = local.config.apps
+}

package/dist/generators/common-resources/firebase/templates/firebase/firebase.yaml

@@ -0,0 +1,17 @@
+# Firebase configuration
+#
+# Naming conventions per platform:
+#   android.package_name  — Java package notation: letters, digits, underscores, and dots only.
+#                           No hyphens. Example: com.example_app.checkout
+#   ios.bundle_id         — Reverse DNS notation: letters, digits, hyphens, and dots only.
+#                           No underscores. Example: com.example-app.checkout
+apps:
+  - display_name: "<%- appDisplayName %>"
+<% if (platforms.includes('android')) { -%>
+    android:
+      package_name: <%- androidPackageName %>
+<% } -%>
+<% if (platforms.includes('ios')) { -%>
+    ios:
+      bundle_id: <%- iosBundleId %>
+<% } -%>

package/dist/generators/common-resources/firebase/templates/firebase/terragrunt.hcl

@@ -0,0 +1,38 @@
+# Terragrunt configuration for Firebase multi-platform application
+# https://github.com/GoogleCloudPlatform/terraform-google-firebase
+
+terraform {
+  source = "git::https://github.com/extenda/terraform-google-firebase//modules/firebase_multi_platform_application/apps?ref=v1.0.0"
+}
+
+include {
+  path = find_in_parent_folders("terragrunt_root.hcl")
+}
+
+generate "firebase_providers" {
+  path      = "firebase_providers.tf"
+  if_exists = "overwrite_terragrunt"
+  contents  = <<EOF
+provider "google" {
+  project               = var.project_id
+  billing_project       = var.project_id
+  user_project_override = true
+}
+
+provider "google-beta" {
+  project               = var.project_id
+  billing_project       = var.project_id
+  user_project_override = true
+}
+EOF
+}
+
+locals {
+  project_vars = read_terragrunt_config(find_in_parent_folders("project.hcl"))
+  config       = yamldecode(file("${get_terragrunt_dir()}/firebase.yaml"))
+}
+
+inputs = {
+  project_id = local.project_vars.locals.project_id
+  apps       = local.config.apps
+}

package/dist/generators/common-resources/firestore/README.md

@@ -0,0 +1,246 @@
+# Firestore Generator
+
+This generator scaffolds a Firestore database configuration for use with Terragrunt and the [terraform-google-firestore](https://github.com/extenda/terraform-google-firestore) module (via wrapper supporting multi-database deployments).
+
+## Generated Files
+
+The generator creates files at the firestore level per environment (prod/staging), supporting **multiple databases** deployed in a single `terragrunt plan`:
+
+Located at `infra/{env}/firestore/`:
+1. **databases.yaml** - Central configuration for all databases with YAML anchors for safe defaults
+2. **schema/*.yaml** - Individual collection schemas (fields and indexes)
+3. **terragrunt.hcl** - Multi-database orchestration that calls the wrapper module via `for_each`
+
+## File Architecture
+
+```
+infra/
+  prod/firestore/
+    databases.yaml              ← All databases + backup schedules with YAML anchors
+    terragrunt.hcl              ← Multi-database orchestration (calls wrapper)
+    schema/
+      users.yaml                ← Fields and indexes for users collection
+      posts.yaml                ← Fields and indexes for posts collection
+  staging/firestore/
+    databases.yaml
+    terragrunt.hcl
+    schema/
+      users.yaml
+      posts.yaml
+```
+
+## Databases YAML Format
+
+The `databases.yaml` file defines all Firestore databases and backup schedules using YAML anchors for reusable defaults.
+
+### Basic Structure
+
+```yaml
+# YAML anchors define reusable backup schedules
+backup_schedule_configuration: &default_backup_schedule
+  weekly_recurrence:
+    day: "MONDAY"
+    retention: "8w"
+
+# All databases in one place
+databases:
+  - name: "database1"
+    backup_schedule_configuration: *default_backup_schedule
+    collections:
+      - schema: schema/users.yaml
+      - schema: schema/posts.yaml
+
+  - name: "database2"
+    backup_schedule_configuration: *default_backup_schedule
+    collections:
+      - schema: schema/users.yaml
+      - schema: schema/posts.yaml
+    # Optional: override delete protection for this database only
+    delete_protection_state: "DELETE_PROTECTION_ENABLED"
+```
+
+### Databases Properties
+
+- **name**: Unique database identifier (required)
+- **backup_schedule_configuration**: Backup schedule using YAML anchors (required)
+  - **daily_recurrence**: For daily backups with retention (e.g., "30d")
+  - **weekly_recurrence**: For weekly backups with day and retention (e.g., "8w")
+- **collections**: List of schema references (required)
+  - **schema**: Path to schema file relative to firestore folder (e.g., `schema/users.yaml`)
+- **delete_protection_state**: Optional override (`DELETE_PROTECTION_ENABLED` or `DELETE_PROTECTION_DISABLED`)
+
+### Example: Multiple Databases
+
+```yaml
+backup_schedule_configuration: &daily
+  daily_recurrence:
+    retention: "30d"
+
+backup_schedule_configuration: &weekly
+  weekly_recurrence:
+    day: "FRIDAY"
+    retention: "12w"
+
+databases:
+  - name: "production-db"
+    backup_schedule_configuration: *weekly
+    collections:
+      - schema: schema/users.yaml
+      - schema: schema/posts.yaml
+      - schema: schema/comments.yaml
+
+  - name: "analytics-db"
+    backup_schedule_configuration: *daily
+    collections:
+      - schema: schema/events.yaml
+      - schema: schema/metrics.yaml
+    delete_protection_state: "DELETE_PROTECTION_DISABLED"
+```
+
+## Schema YAML Format
+
+Each schema file in `schema/` defines the TTL field and composite indexes for a collection.
+
+### Basic Structure
+
+```yaml
+name: users
+description: "User profiles with indexes"
+
+ttl_field: expires_at
+
+indexes:
+  - name: email_created_index
+    fields:
+    - field_path: "email"
+      order: "ASCENDING"
+      array_config: null
+    - field_path: "created_at"
+      order: "ASCENDING"
+      array_config: null
+    - field_path: "__name__"
+      order: "ASCENDING"
+      array_config: null
+```
+
+### TTL Field
+
+- **ttl_field**: The name of the field that has Time To Live enabled (optional scalar, omit if no TTL). Only one field per collection can have TTL.
+
+### Index Properties
+
+- **name**: Index name (required, must be unique within the database)
+- **fields**: List of fields in the composite index
+  - **field_path**: Field name (required, quoted string)
+  - **order**: `"ASCENDING"` or `"DESCENDING"` for ordered fields; `null` for array fields
+  - **array_config**: `"CONTAINS"` for array-contains queries; `null` for ordered fields
+
+### Example: Complete Schema
+
+```yaml
+name: posts
+description: "Blog posts with advanced indexing"
+
+ttl_field: expires_at
+
+indexes:
+  - name: posts_by_author_created
+    fields:
+    - field_path: "author_id"
+      order: "ASCENDING"
+      array_config: null
+    - field_path: "created_at"
+      order: "ASCENDING"
+      array_config: null
+    - field_path: "__name__"
+      order: "ASCENDING"
+      array_config: null
+
+  - name: posts_by_tags
+    fields:
+    - field_path: "tags"
+      array_config: "CONTAINS"
+      order: null
+    - field_path: "created_at"
+      order: "ASCENDING"
+      array_config: null
+    - field_path: "__name__"
+      order: "ASCENDING"
+      array_config: null
+```
+
+## Terragrunt Configuration
+
+The `terragrunt.hcl` file automatically handles multi-database orchestration with safe defaults.
+
+### Safe Defaults
+
+The terragrunt.hcl applies safe defaults to all databases:
+
+```hcl
+default_database_config = {
+  location                           = "europe-west1"
+  database_type                      = "FIRESTORE_NATIVE"
+  concurrency_mode                   = "OPTIMISTIC"
+  delete_protection_state            = "DELETE_PROTECTION_ENABLED"  # ← Prevents accidental deletion
+  deletion_policy                    = "DELETE"
+  point_in_time_recovery_enablement  = "POINT_IN_TIME_RECOVERY_DISABLED"
+  kms_key_name                       = null
+}
+```
+
+These defaults are merged with database-specific overrides in `databases.yaml`. Each database inherits all defaults unless explicitly overridden.
+
+### Multi-Database Deployment
+
+When you run `terragrunt plan`, it:
+1. Loads all databases from `databases.yaml`
+2. Loads all schemas from `schema/*.yaml`
+3. Merges each database config with safe defaults
+4. Calls the wrapper module via `for_each` for each database
+5. Shows all resources for all databases in one plan
+
+## Editing Configurations
+
+After generation, you can:
+
+1. **Modify databases.yaml** to:
+   - Add/remove databases
+   - Adjust backup schedules using YAML anchors
+   - Override delete_protection_state per database
+   - Add/remove collections per database
+   - Reference existing or new schema files
+
+2. **Modify schema/*.yaml** to:
+   - Add/remove fields
+   - Add/remove composite indexes
+   - Adjust field ordering and indexing
+
+3. **Leave terragrunt.hcl as-is** - it orchestrates the wrapper module automatically with safe defaults
+
+## Using Different Configurations Per Environment
+
+The generator creates identical files for prod and staging. You can customize each environment by editing:
+- `infra/prod/firestore/databases.yaml`
+- `infra/staging/firestore/databases.yaml`
+
+To use existing schemas across multiple databases, reference the same schema files in multiple database entries in `databases.yaml`:
+
+```yaml
+databases:
+  - name: "db1"
+    collections:
+      - schema: schema/users.yaml    # Reuse schema
+  - name: "db2"
+    collections:
+      - schema: schema/users.yaml    # Same schema in different database
+```
+
+## Firestore Constraints
+
+- **TTL Limit**: Only ONE field per database can have TTL enabled (mark with `ttl_enabled: true`)
+- **Single-Field Indexes**: Use `order` for non-array fields to enable efficient sorting/filtering
+- **Array Indexes**: Use `array_config: CONTAINS` for array fields to enable array-contains queries
+- **Composite Indexes**: Automatically include `__name__` field at the end for document ID ordering
+- **Collections**: Implicitly created when documents are added (no Terraform resource for collection itself)
+- **Schema Reuse**: Multiple databases can reference the same schema file

package/dist/generators/common-resources/firestore/index.js

@@ -3,6 +3,10 @@ const chalk = require('chalk');
 const BaseGenerator = require('../../../src/BaseGenerator');
 const { required } = require('../../../src/validators');
 const getTribeAndClanName = require('../../init/clan-infra/tribe-clan-repo');
+const {
+  validateTtlField,
+  validateCompositeIndexName,
+} = require('./validators');
 
 module.exports = class extends BaseGenerator {
   prompting() {
@@ -24,32 +28,31 @@ module.exports = class extends BaseGenerator {
       },
       {
         type: 'list',
-        name: 'databaseConcurrencyMode',
+        name: 'concurrencyMode',
         message: 'Select the database concurrency mode.',
-        default: 'OPTIMISTIC',
+        default: 'PESSIMISTIC',
         choices: ['OPTIMISTIC', 'PESSIMISTIC'],
       },
       {
-        type: 'list',
-        name: 'databaseBackupEnabled',
-        message: 'Enable database backup?',
-        default: 'true',
-        choices: ['true', 'false'],
+        type: 'input',
+        name: 'location',
+        default: 'europe-west1',
+        message:
+          'Please provide the database location (e.g., europe-west1, us-central1).',
+        validate: required,
       },
       {
-        when: (response) => response.databaseBackupEnabled === 'true',
         type: 'list',
-        name: 'databaseBackupSchedule',
-        message: 'Select the backup schedule.',
+        name: 'backupSchedule',
+        message: 'Enable database backups?',
         default: 'daily-backup',
-        choices: ['daily-backup', 'weekly-backup'],
+        choices: ['daily-backup', 'weekly-backup', 'none'],
       },
       {
-        when: (response) => response.databaseBackupSchedule === 'weekly-backup',
+        when: (response) => response.backupSchedule === 'weekly-backup',
         type: 'list',
-        name: 'databaseBackupWeeklyRecurrence',
-        message:
-          'Please provide the day of the week the backup must be created.',
+        name: 'backupWeeklyDay',
+        message: 'Select the day for weekly backups.',
         default: 'SUNDAY',
         choices: [
           'MONDAY',
@@ -62,93 +65,238 @@ module.exports = class extends BaseGenerator {
         ],
       },
       {
-        when: (response) => response.databaseBackupEnabled === 'true',
+        when: (response) => response.backupSchedule !== 'none',
         type: 'input',
-        name: 'databaseBackupRetention',
-        default: '259200s',
-        message:
-          'Please provide how long to keep the backups in seconds. ex. "259200s" is 3 days',
+        name: 'backupRetention',
+        default: (response) =>
+          response.backupSchedule === 'weekly-backup' ? '1209600s' : '259200s',
+        message: (response) => {
+          const days =
+            response.backupSchedule === 'weekly-backup' ? '14 days' : '3 days';
+          const seconds =
+            response.backupSchedule === 'weekly-backup'
+              ? '1209600s'
+              : '259200s';
+          return `Please provide backup retention in seconds (e.g., "${seconds}" is ${days}).`;
+        },
         validate: required,
       },
       {
         type: 'input',
-        name: 'databaseCollectionName',
-        message: 'Please provide the name of the collection being indexed.',
+        name: 'collectionName',
+        message: 'Please provide the name of the collection.',
         validate: required,
       },
       {
         type: 'input',
-        name: 'databaseCollectionIndexName',
-        message: 'Please provide the name of the index.',
-        validate: required,
+        name: 'collectionDescription',
+        message: 'Please provide a description for this collection.',
+        default: '',
       },
       {
         type: 'input',
-        name: 'databaseCollectionFieldPath',
-        message: 'Please provide the name of the field.',
-        validate: required,
+        name: 'ttlField',
+        message: 'Which field should have TTL enabled? (leave blank for none)',
+        default: '',
+        validate: validateTtlField,
       },
       {
-        type: 'list',
-        name: 'databaseCollectionFieldorder',
-        message: 'Select the specified order for the field.',
-        default: 'ASCENDING',
-        choices: ['ASCENDING', 'DESCENDING'],
+        type: 'input',
+        name: 'compositeIndexFields',
+        message:
+          'Which fields should be in composite indexes? (comma-separated, leave blank for none)',
+        default: '',
+      },
+      {
+        when: (response) => response.compositeIndexFields.trim().length > 0,
+        type: 'input',
+        name: 'compositeIndexName',
+        message:
+          'Please provide a name for the composite index.\n  (the name must be unique within the database, e.g., "<collection>-index-1")',
+        validate: validateCompositeIndexName,
+      },
+      {
+        when: (response) => response.compositeIndexFields.trim().length > 0,
+        type: 'input',
+        name: 'arrayFieldsInComposite',
+        message:
+          'Which fields in the composite index are array fields? (comma-separated, leave blank for none)',
+        default: '',
       },
     ];
 
     return this.prompt(prompts).then((props) => {
       this.answers = props;
+
+      // Check for existing files (databases.yaml and schema files)
+      const existingFiles = [];
+      ['prod', 'staging'].forEach((env) => {
+        const databasesPath = this.destinationPath(
+          path.join('infra', env, 'firestore', 'databases.yaml'),
+        );
+        const schemaDir = this.destinationPath(
+          path.join('infra', env, 'firestore', 'schema'),
+        );
+
+        if (this.fs.exists(databasesPath)) {
+          existingFiles.push(`infra/${env}/firestore/databases.yaml`);
+        }
+        if (this.fs.exists(schemaDir)) {
+          existingFiles.push(`infra/${env}/firestore/schema/`);
+        }
+      });
+
+      if (existingFiles.length > 0) {
+        return this.prompt([
+          {
+            type: 'list',
+            name: 'existingFilesAction',
+            message: `Found existing firestore files: ${existingFiles.join(', ')}. What do you want to do?`,
+            choices: [
+              { name: 'Use existing schema', value: 'use' },
+              { name: 'Overwrite with new configuration', value: 'overwrite' },
+            ],
+          },
+        ]).then((action) => {
+          this.answers.existingFilesAction = action.existingFilesAction;
+        });
+      }
     });
   }
 
   writing() {
-    const { databaseName, databaseCollectionName, ...rest } = this.answers;
+    const {
+      databaseName,
+      collectionName,
+      collectionDescription,
+      ttlField,
+      compositeIndexFields,
+      compositeIndexName,
+      arrayFieldsInComposite,
+      ...rest
+    } = this.answers;
+
+    const ttlFields = ttlField ? [ttlField.trim()] : [];
+    const compositeFields = compositeIndexFields
+      ? compositeIndexFields
+          .split(',')
+          .map((f) => f.trim())
+          .filter(Boolean)
+      : [];
+    const compositeArrayFields = arrayFieldsInComposite
+      ? arrayFieldsInComposite
+          .split(',')
+          .map((f) => f.trim())
+          .filter(Boolean)
+      : [];
+
+    // Build schema file content
+    let schemaYaml =
+      '# The last field entry is always for the field path __name__.\n' +
+      '# If, on creation, __name__ was not specified as the last field,\n' +
+      '# it will be added automatically with the same direction as that of the last field defined.\n' +
+      '# If the final field in a composite index is not directional, the __name__ will be ordered "ASCENDING".\n' +
+      '# Index names must be unique within the database, e.g., "<collection name>-index-1"\n\n';
+    schemaYaml += `name: ${collectionName}\n`;
+    schemaYaml += `description: "${collectionDescription || collectionName}"\n\n`;
+
+    if (ttlFields.length > 0) {
+      schemaYaml += `ttl_field: ${ttlFields[0]}\n`;
+    }
+
+    if (compositeFields.length > 0) {
+      schemaYaml += 'indexes:\n';
+      schemaYaml += `  - name: ${compositeIndexName}\n`;
+      schemaYaml += '    fields:\n';
+
+      compositeFields.forEach((field) => {
+        schemaYaml += `    - field_path: ${field}\n`;
+        if (compositeArrayFields.includes(field)) {
+          schemaYaml += `      array_config: "CONTAINS"\n`;
+          schemaYaml += `      order: null\n`;
+        } else {
+          schemaYaml += `      order: "ASCENDING"\n`;
+          schemaYaml += `      array_config: null\n`;
+        }
+      });
+
+      // Add __name__ field at the end
+      schemaYaml += `    - field_path: "__name__"\n`;
+      schemaYaml += `      order: "ASCENDING"\n`;
+      schemaYaml += `      array_config: null\n`;
+    }
 
     ['prod', 'staging'].forEach((env) => {
       const context = {
         ...rest,
         databaseName,
-        databaseCollectionName,
+        databaseType: this.answers.databaseType,
+        collectionName,
         env,
       };
-      const baseDest = path.join('infra', env, 'firestore', databaseName);
-      const collectionDest = path.join(
-        baseDest,
-        'indexes',
-        databaseCollectionName,
-      );
+      const firestoreDest = path.join('infra', env, 'firestore');
 
-      // Files to copy at database root
-      ['spec.hcl', 'terragrunt.hcl'].forEach((file) => {
-        this.fs.copyTpl(
-          this.templatePath('firestore', file),
-          this.destinationPath(baseDest, file),
-          context,
+      // Only write databases.yaml and schema if not using existing
+      if (this.answers.existingFilesAction !== 'use') {
+        const databasesPath = this.destinationPath(
+          firestoreDest,
+          'databases.yaml',
         );
-      });
+        const schemaDir = this.destinationPath(firestoreDest, 'schema');
+        const schemaFileName = `${collectionName.toLowerCase()}.yaml`;
+        const schemaPath = this.destinationPath(schemaDir, schemaFileName);
+
+        // Delete existing files first to avoid Yeoman conflict prompts
+        if (this.fs.exists(databasesPath)) {
+          this.fs.delete(databasesPath);
+        }
+        if (this.fs.exists(schemaPath)) {
+          this.fs.delete(schemaPath);
+        }
 
-      // Files to copy inside indexes/<databaseCollectionName>/
-      ['indexes.yaml', 'terragrunt.hcl'].forEach((file) => {
+        // Copy databases.yaml to firestore folder
         this.fs.copyTpl(
-          this.templatePath('firestore/indexes', file),
-          this.destinationPath(collectionDest, file),
+          this.templatePath('firestore', 'databases.yaml'),
+          databasesPath,
           context,
         );
-      });
+
+        // Write schema file to schema/ subdirectory
+        this.fs.write(schemaPath, schemaYaml);
+      }
+
+      // Copy terragrunt.hcl to firestore folder (multi-database wrapper)
+      this.fs.copyTpl(
+        this.templatePath('firestore', 'terragrunt.hcl'),
+        this.destinationPath(firestoreDest, 'terragrunt.hcl'),
+        context,
+      );
     });
   }
 
   end() {
-    const { databaseName } = this.answers;
-
-    const firestoreDir = path.join(databaseName);
-    this.log(`
-${chalk.green(`Your Firestore database has now been created. To finalize your configuration, please continue
-with manual editing of the generated files.`)}
-${chalk.green('1.')} Review and add more indexes as the firestore module requires at least two.
-   \u2192 ${chalk.cyan(path.join(firestoreDir, 'indexes.yaml'))}
-${chalk.green('2.')} Push this change in a feature branch and open a pull request.
-`);
+    const { existingFilesAction } = this.answers;
+
+    const header = chalk.green(
+      'Your Firestore database has now been created. Review the generated configuration:',
+    );
+    let message = header;
+
+    if (existingFilesAction === 'use') {
+      const databasesPreserved = `${chalk.green('1.')} ${chalk.cyan(path.join('firestore', 'databases.yaml'))} - ${chalk.yellow('(preserved existing file)')}`;
+      const schemaPreserved = `${chalk.green('2.')} ${chalk.cyan(path.join('firestore', 'schema', '*'))} - ${chalk.yellow('(preserved existing files)')}`;
+      message += `\n${databasesPreserved}`;
+      message += `\n${schemaPreserved}`;
+    } else {
+      const databasesNew = `${chalk.green('1.')} ${chalk.cyan(path.join('firestore', 'databases.yaml'))} - Database configuration with defaults`;
+      const schemaNew = `${chalk.green('2.')} ${chalk.cyan(path.join('firestore', 'schema', '*'))} - Collection schema files`;
+      message += `\n${databasesNew}`;
+      message += `\n${schemaNew}`;
+    }
+
+    const terragruntFile = `${chalk.green('3.')} ${chalk.cyan(path.join('firestore', 'terragrunt.hcl'))} - Multi-database orchestration`;
+    message += `\n${terragruntFile}`;
+
+    this.log(`\n${message}\n`);
   }
 };

package/dist/generators/common-resources/firestore/templates/firestore/databases.yaml

@@ -0,0 +1,26 @@
+# Firestore Databases Configuration
+#
+# Defaults are configured in terragrunt.hcl
+# Each database only needs:
+#   - name: unique identifier
+#   - collections: list of schema references or inline definitions
+#   - backup_schedule_configuration: backup schedule
+#   - (optional) any field overrides
+
+backup_schedule_configuration: &default_backup_schedule
+<% if (backupSchedule === 'daily-backup') { %>
+  daily_recurrence:
+    retention: "<%- backupRetention %>"
+<% } else if (backupSchedule === 'weekly-backup') { %>
+  weekly_recurrence:
+    day: "<%- backupWeeklyDay %>"
+    retention: "<%- backupRetention %>"
+<% } else { %>
+  null
+<% } %>
+
+databases:
+  - name: "<%- databaseName %>"
+    backup_schedule_configuration: *default_backup_schedule
+    collections:
+      - schema: schema/<%= collectionName.toLowerCase() %>.yaml

package/dist/generators/common-resources/firestore/templates/firestore/terragrunt.hcl

@@ -1,7 +1,8 @@
-# Terragrunt will copy the Terraform configurations specified by the source parameter, along with any files in the
-# working directory, into a temporary folder, and execute your Terraform commands in that folder.
+# Terragrunt configuration for Firestore databases using the multi-database wrapper
+# https://github.com/extenda/terraform-google-firestore
+
 terraform {
-  source = "git::https://github.com/extenda/tf-module-gcp-firestore//modules/database?ref=v1.0.2"
+  source = "git::https://github.com/extenda/terraform-google-firestore//databases?ref=v1.0.0"
 }
 
 # Include all settings from the root terragrunt.hcl file
@@ -10,16 +11,103 @@ include {
 }
 
 locals {
-  project_vars  = read_terragrunt_config(find_in_parent_folders("project.hcl"))
-  database_name = basename(get_terragrunt_dir())
-  database_spec_vars = read_terragrunt_config("${get_terragrunt_dir()}/spec.hcl")
+  # Load project variables
+  project_vars = read_terragrunt_config(find_in_parent_folders("project.hcl"))
+
+  # Default configuration for all databases
+  default_database_config = {
+    location                           = "<%- location %>"
+    database_type                      = "<%- databaseType %>"
+    concurrency_mode                   = "<%- concurrencyMode %>"
+    delete_protection_state            = "DELETE_PROTECTION_ENABLED"
+    deletion_policy                    = "DELETE"
+    point_in_time_recovery_enablement  = "POINT_IN_TIME_RECOVERY_DISABLED"
+    kms_key_name                       = null
+  }
+
+  # Load database configuration from databases.yaml
+  database_config = yamldecode(file("${get_terragrunt_dir()}/databases.yaml"))
+
+  # Get all databases from databases.yaml and merge with defaults
+  all_databases = [
+    for db in try(local.database_config.databases, []) :
+    merge(local.default_database_config, db)
+  ]
+
+  # Build field and index configurations for each database
+  databases_collections = {
+    for db in local.all_databases : db.name => try(db.collections, [])
+  }
+
+  # Load collection schemas from referenced files OR inline definitions
+  collection_schemas = {
+    for db_name, collections in local.databases_collections : db_name => {
+      for collection in collections :
+      (try(collection.schema, null) != null ? yamldecode(file("${get_terragrunt_dir()}/${collection.schema}")).name : collection.name) => merge(
+        {
+          name        = try(collection.schema, null) != null ? yamldecode(file("${get_terragrunt_dir()}/${collection.schema}")).name : collection.name
+          description = try(collection.schema, null) != null ? yamldecode(file("${get_terragrunt_dir()}/${collection.schema}")).description : try(collection.description, "")
+          ttl_field   = try(collection.schema, null) != null ? try(yamldecode(file("${get_terragrunt_dir()}/${collection.schema}")).ttl_field, null) : try(collection.ttl_field, null)
+          indexes     = try(collection.schema, null) != null ? try(yamldecode(file("${get_terragrunt_dir()}/${collection.schema}")).indexes, []) : try(collection.indexes, [])
+        }
+      )
+    }
+  }
+
+  # Build field configuration for each database (TTL fields only)
+  databases_field_configuration = {
+    for db_name, schemas in local.collection_schemas : db_name => flatten([
+      for schema_name, schema in schemas :
+      try(schema.ttl_field, null) != null ? [
+        {
+          collection  = schema_name
+          field       = schema.ttl_field
+          ttl_enabled = true
+        }
+      ] : []
+    ])
+  }
+
+  # Build composite index configuration for each database
+  databases_composite_index_configuration = {
+    for db_name, schemas in local.collection_schemas : db_name => flatten([
+      for schema_name, schema in schemas : [
+        for idx, index in try(schema.indexes, []) :
+        {
+          index_id   = index.name
+          collection = schema_name
+          query_scope = try(index.query_scope, "COLLECTION")
+          api_scope  = try(index.api_scope, "ANY_API")
+          fields = [
+            for field_config in try(index.fields, []) : {
+              field_path    = field_config.field_path
+              order         = try(field_config.order, "ASCENDING")
+              array_config  = try(field_config.array_config, null)
+              vector_config = try(field_config.vector_config, null)
+            }
+          ]
+        }
+      ]
+    ])
+  }
 }
 
-# These are the variables we have to pass in to use the module specified in the terragrunt configuration above
-inputs = merge(
-    local.database_spec_vars.locals,
-    {
-      project_id = local.project_vars.locals.project_id,
-      database_name = local.database_name
+# Inputs to pass to the multi-database wrapper
+inputs = {
+  project_id = local.project_vars.locals.project_id
+  databases = {
+    for db in local.all_databases : db.name => {
+      database_id                        = db.name
+      location                           = db.location
+      database_type                      = db.database_type
+      concurrency_mode                   = db.concurrency_mode
+      delete_protection_state            = db.delete_protection_state
+      backup_schedule_configuration      = db.backup_schedule_configuration
+      point_in_time_recovery_enablement  = db.point_in_time_recovery_enablement
+      deletion_policy                    = db.deletion_policy
+      kms_key_name                       = db.kms_key_name
+      field_configuration                = local.databases_field_configuration[db.name]
+      composite_index_configuration      = local.databases_composite_index_configuration[db.name]
     }
-)
+  }
+}

package/dist/generators/common-resources/firestore/validators.js

@@ -0,0 +1,22 @@
+module.exports = {
+  validateTtlField: (input) => {
+    if (input.trim() === '') {
+      return true;
+    }
+    if (input.includes(',')) {
+      return 'Please enter only one field for TTL. Multiple fields are not supported.';
+    }
+    return true;
+  },
+
+  validateCompositeIndexName: (input) => {
+    const trimmedInput = input.trim();
+    if (!trimmedInput) {
+      return 'Composite index name is required';
+    }
+    if (trimmedInput.includes(',')) {
+      return 'Please enter only one name for the composite index';
+    }
+    return true;
+  },
+};

package/dist/node_modules/.package-lock.json

@@ -11528,7 +11528,7 @@
     },
     "packages/generators": {
       "name": "@hiiretail/gcp-infra-generators",
-      "version": "1.9.0",
+      "version": "1.11.0",
       "license": "MIT",
       "dependencies": {
         "@google-cloud/storage": "^7.18.0",

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hiiretail/gcp-infra-generators",
-  "version": "1.9.0",
+  "version": "1.11.0",
   "description": "Infrastructure as code generator for GCP.",
   "scripts": {
     "build": "node esbuild.js && npm run build:deps",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hiiretail/gcp-infra-generators",
-  "version": "1.9.0",
+  "version": "1.11.0",
   "description": "Infrastructure as code generator for GCP.",
   "scripts": {
     "build": "node esbuild.js && npm run build:deps",

package/dist/generators/common-resources/firestore/templates/firestore/indexes/indexes.yaml

@@ -1,12 +0,0 @@
-# The last field entry is always for the field path __name__.
-# If, on creation, __name__ was not specified as the last field,
-# it will be added automatically with the same direction as that of the last field defined.
-# If the final field in a composite index is not directional, the __name__ will be ordered "ASCENDING".
-indexes:
-  <%-databaseCollectionIndexName%>:
-    - field_path: "<%-databaseCollectionFieldPath%>"
-      array_config: "CONTAINS"
-      order: "<%-databaseCollectionFieldorder%>"
-    - field_path: "__name__"
-      order: "<%-databaseCollectionFieldorder%>"
-      array_config: null

package/dist/generators/common-resources/firestore/templates/firestore/indexes/terragrunt.hcl

@@ -1,27 +0,0 @@
-# Terragrunt will copy the Terraform configurations specified by the source parameter, along with any files in the
-# working directory, into a temporary folder, and execute your Terraform commands in that folder.
-terraform {
-  source = "git::https://github.com/extenda/tf-module-gcp-firestore//modules/index?ref=v1.0.0"
-}
-
-# Include all settings from the root terragrunt.hcl file
-include {
-  path = find_in_parent_folders("terragrunt_root.hcl")
-}
-
-locals {
-  project_vars = read_terragrunt_config(find_in_parent_folders("project.hcl"))
-  collection = basename(get_terragrunt_dir())
-  database_name = basename(dirname(dirname(get_terragrunt_dir())))
-}
-
-# These are the variables we have to pass in to use the module specified in the terragrunt configuration above
-inputs = merge(
-  yamldecode(
-    file("${get_terragrunt_dir()}/indexes.yaml")),
-    {
-      project_id = local.project_vars.locals.project_id
-      database_name = local.database_name
-      collection = local.collection
-    }
-)

package/dist/generators/common-resources/firestore/templates/firestore/spec.hcl

@@ -1,31 +0,0 @@
-locals {
-  ###################
-  # REQUIRED INPUTS #
-  ###################
-
-  database_location_id          = "europe-west1"
-  database_type                 = "<%- databaseType %>"
-  database_concurrency_mode     = "<%- databaseConcurrencyMode %>"
-
-  ###################
-  # OPTIONAL INPUTS #
-  ###################
-
-  # Description: Enables protection of a Firestore database from accidental deletion across all surfaces (API, gcloud, Cloud Console, and Terraform).
-  #Type: String
-  #Default: "DELETE_PROTECTION_DISABLED"
-  database_delete_protection_state      = "DELETE_PROTECTION_ENABLED"
-
-  <% if (databaseBackupEnabled === 'true') { %>
-  #Type: Bool
-  #Default: true
-  # Description: Firestore backup settings
-  database_backup_enabled                     = true
-  database_backup_schedule                    = "<%- databaseBackupSchedule %>"
-  <% if (databaseBackupSchedule === 'weekly-backup') { %>
-  database_backup_weekly_recurrence           = "<%- databaseBackupWeeklyRecurrence %>"
-  <% } %>
-  database_point_in_time_recovery_enablement  = "POINT_IN_TIME_RECOVERY_DISABLED"
-  database_backup_retention                   = "<%- databaseBackupRetention %>"
-  <% } %>
-}