nsa-sheets-db-builder 4.0.0

package/scripts/login.mjs

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+
+/**
+ * Login to Google for a DB project using clasp 3.x named profiles.
+ *
+ * Usage:
+ *   node scripts/login.mjs --db <name> [--env <env>] [--account user@gmail.com]
+ *
+ * Flow:
+ *   1. Ask for the Gmail account (or use --account flag / existing config)
+ *   2. Run `clasp login --user <dbName>--<env>`
+ *   3. Verify the logged-in account matches the specified one
+ *   4. Store email in .nsaproject.json → environments.<env>.account
+ */
+
+import readline from 'readline';
+import { execSync } from 'child_process';
+import { parseArgs, requireDb, loadDbConfig, getEnvConfig, getClaspUserProfile, getAccountEmail, resolveAccount, loadRootConfig, saveRootConfig } from './lib/utils.mjs';
+
+function prompt(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+const args = parseArgs();
+const dbName = requireDb(args, 'login.mjs');
+const config = loadDbConfig(dbName);
+const { env, envConfig } = getEnvConfig(config, args.env);
+
+const profile = getClaspUserProfile(dbName, env);
+
+// 1. Determine expected account
+let expectedAccount = args.account || resolveAccount(envConfig, env) || '';
+
+if (!expectedAccount) {
+  console.log(`\nLogin for ${dbName} (${env})`);
+  console.log(`  Profile: ${profile}\n`);
+  expectedAccount = await prompt('Enter the Gmail account to use: ');
+
+  if (!expectedAccount) {
+    console.error('No account specified. Aborting.');
+    process.exit(1);
+  }
+}
+
+// Basic email validation
+if (!expectedAccount.includes('@')) {
+  console.error(`Invalid email: "${expectedAccount}"`);
+  process.exit(1);
+}
+
+console.log(`\nLogging in as ${expectedAccount} for ${dbName} (${env})...`);
+console.log(`  Profile: ${profile}`);
+console.log('\nA browser window will open. Please sign in with the account above.\n');
+
+// 2. Run clasp login
+try {
+  execSync(`npx --prefer-offline @google/clasp login --user ${profile}`, { stdio: 'inherit' });
+} catch {
+  console.error('\nclasp login failed.');
+  process.exit(1);
+}
+
+// 3. Verify the logged-in account matches
+const actualEmail = await getAccountEmail(profile);
+
+if (!actualEmail) {
+  console.warn('\nWarning: Could not verify account email (token may not have userinfo scope).');
+  console.log('Saving specified account to config anyway.\n');
+  const rc1 = loadRootConfig();
+  if (!rc1.environments) rc1.environments = {};
+  if (!rc1.environments[env]) rc1.environments[env] = {};
+  rc1.environments[env].account = expectedAccount;
+  saveRootConfig(rc1);
+  console.log(`Login complete for ${dbName} (${env})`);
+  console.log(`  Profile: ${profile}`);
+  console.log(`  Account (unverified): ${expectedAccount}`);
+  process.exit(0);
+}
+
+if (actualEmail.toLowerCase() !== expectedAccount.toLowerCase()) {
+  console.error(`\nAccount mismatch!`);
+  console.error(`  Expected: ${expectedAccount}`);
+  console.error(`  Got:      ${actualEmail}`);
+  console.error(`\nPlease run login again and sign in with the correct account.`);
+  process.exit(1);
+}
+
+// 4. Store account in root config
+const rc2 = loadRootConfig();
+if (!rc2.environments) rc2.environments = {};
+if (!rc2.environments[env]) rc2.environments[env] = {};
+rc2.environments[env].account = actualEmail;
+saveRootConfig(rc2);
+
+console.log(`\nLogged in as ${actualEmail} for ${dbName} (${env})`);
+console.log(`  Profile: ${profile}`);

package/scripts/provision.mjs

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+
+/**
+ * Provision tables from tables.json into data spreadsheets.
+ *
+ * Usage:
+ *   node scripts/provision.mjs --db <name> [--env <env>] [--instance <type>]
+ */
+
+import { parseArgs, requireDb, loadDbConfig, getEnvConfig, getDistDirForInstance, claspRun, loadTables, requireDataSpreadsheet, requireInstance, ensureAuthenticated } from './lib/utils.mjs';
+
+const args = parseArgs();
+const dbName = requireDb(args, 'provision.mjs');
+const config = loadDbConfig(dbName);
+const { env, envConfig } = getEnvConfig(config, args.env);
+const instance = requireInstance(args, envConfig);
+const distDir = getDistDirForInstance(dbName, instance.type);
+
+const tables = loadTables(dbName);
+const spreadsheetId = requireDataSpreadsheet(tables, dbName);
+const tableNames = Object.keys(tables);
+
+// Auth enforcement
+const userProfile = await ensureAuthenticated(dbName, args, envConfig, env);
+
+console.log(`Provisioning ${tableNames.length} table(s) for ${dbName} (${env}, ${instance.type})...`);
+console.log(`  Tables: ${tableNames.join(', ')}`);
+console.log(`  Data spreadsheet: ${spreadsheetId}`);
+
+const result = claspRun(distDir, 'ddlProvisionTables', [{
+  spreadsheetId,
+  tables
+}], { userProfile });
+
+console.log('\nResult:', JSON.stringify(result, null, 2));

package/scripts/refresh-cache.mjs

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+
+/**
+ * Manually refresh the __sys__tables__ cache and CacheService.
+ *
+ * Usage:
+ *   node scripts/refresh-cache.mjs --db <name> [--env <env>] [--instance <type>]
+ */
+
+import { parseArgs, requireDb, loadDbConfig, getEnvConfig, getDistDirForInstance, claspRun, requireInstance, ensureAuthenticated } from './lib/utils.mjs';
+
+const args = parseArgs();
+const dbName = requireDb(args, 'refresh-cache.mjs');
+const config = loadDbConfig(dbName);
+const { env, envConfig } = getEnvConfig(config, args.env);
+const instance = requireInstance(args, envConfig);
+const distDir = getDistDirForInstance(dbName, instance.type);
+
+const sysId = envConfig.systemSpreadsheetId;
+if (!sysId) {
+  console.error(`No systemSpreadsheetId set for environment "${env}".`);
+  console.error('Run "nsa-sheets-db-builder create -- --db <name>" first.');
+  process.exit(1);
+}
+
+// Auth enforcement
+const userProfile = await ensureAuthenticated(dbName, args, envConfig, env);
+
+console.log(`Refreshing cache for ${dbName} (${env}, ${instance.type})...`);
+console.log(`  System spreadsheet: ${sysId}`);
+
+const result = claspRun(distDir, 'ddlRefreshCache', [{ systemSpreadsheetId: sysId }], { userProfile });
+
+console.log('\nResult:', JSON.stringify(result, null, 2));

package/scripts/set-key.mjs

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+
+/**
+ * Set or rotate the DDL API key (stored in GAS Script Properties).
+ * Requires --instance since each GAS project has its own Script Properties.
+ *
+ * Usage:
+ *   node scripts/set-key.mjs --db <name> --key <key> [--instance <type>]
+ *   node scripts/set-key.mjs --db <name> --rotate [--instance <type>]
+ *   node scripts/set-key.mjs --db <name> --show [--instance <type>]
+ */
+
+import { parseArgs, requireDb, loadDbConfig, getEnvConfig, getDistDirForInstance, claspRun, requireInstance, ensureAuthenticated } from './lib/utils.mjs';
+
+const args = parseArgs();
+const dbName = requireDb(args, 'set-key.mjs');
+const config = loadDbConfig(dbName);
+const { env, envConfig } = getEnvConfig(config, args.env);
+const instance = requireInstance(args, envConfig);
+const distDir = getDistDirForInstance(dbName, instance.type);
+
+// Auth enforcement
+const userProfile = await ensureAuthenticated(dbName, args, envConfig, env);
+
+if (args.show) {
+  console.log(`Checking DDL API key for ${dbName} (${env}, ${instance.type})...`);
+  const result = claspRun(distDir, 'ddlGetApiKey', [], { userProfile });
+  console.log('\nResult:', JSON.stringify(result, null, 2));
+} else if (args.rotate) {
+  console.log(`Rotating DDL API key for ${dbName} (${env}, ${instance.type})...`);
+  const result = claspRun(distDir, 'ddlRotateApiKey', [], { userProfile });
+  if (result?.key) {
+    console.log(`\nNew API key: ${result.key}`);
+    console.log('Store this key securely — it will not be shown again.');
+  } else {
+    console.log('\nResult:', JSON.stringify(result, null, 2));
+  }
+} else if (args.key) {
+  console.log(`Setting DDL API key for ${dbName} (${env}, ${instance.type})...`);
+  const result = claspRun(distDir, 'ddlSetApiKey', [{ key: args.key }], { userProfile });
+  console.log('\nResult:', JSON.stringify(result, null, 2));
+} else {
+  console.error('Usage:');
+  console.error('  node scripts/set-key.mjs --db <name> --key <key> [--instance <type>]');
+  console.error('  node scripts/set-key.mjs --db <name> --rotate [--instance <type>]');
+  console.error('  node scripts/set-key.mjs --db <name> --show [--instance <type>]');
+  process.exit(1);
+}

package/scripts/setup-trigger.mjs

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+
+/**
+ * Set up or remove table-level triggers from tables.json.
+ * The system trigger (refreshTableCache) is set up automatically during create.
+ *
+ * Usage:
+ *   node scripts/setup-trigger.mjs --db <name> [--instance <type>]             Set up all table triggers
+ *   node scripts/setup-trigger.mjs --db <name> --function <name>               Set up one trigger
+ *   node scripts/setup-trigger.mjs --db <name> --remove [--instance <type>]    Remove all triggers
+ *   node scripts/setup-trigger.mjs --db <name> --remove --function <name>      Remove one trigger
+ *   node scripts/setup-trigger.mjs --db <name> --list                          List configured triggers
+ */
+
+import { parseArgs, requireDb, loadDbConfig, getEnvConfig, getDistDirForInstance, claspRun, requireInstance, ensureAuthenticated, loadTables } from './lib/utils.mjs';
+
+const args = parseArgs();
+const dbName = requireDb(args, 'setup-trigger.mjs');
+const config = loadDbConfig(dbName);
+const { env, envConfig } = getEnvConfig(config, args.env);
+const instance = requireInstance(args, envConfig);
+const distDir = getDistDirForInstance(dbName, instance.type);
+
+// Collect triggers from all tables
+const tables = loadTables(dbName);
+const triggers = [];
+for (const [tableName, tableDef] of Object.entries(tables)) {
+  if (tableDef.triggers && Array.isArray(tableDef.triggers)) {
+    for (const t of tableDef.triggers) {
+      triggers.push({ ...t, table: tableName });
+    }
+  }
+}
+
+// List configured triggers
+if (args.list) {
+  console.log(`Triggers for ${dbName} (${env}):\n`);
+  console.log('  System (mandatory):');
+  console.log('    refreshTableCache — hourly cache refresh (auto)');
+  if (triggers.length === 0) {
+    console.log('\n  Table triggers: (none)');
+  } else {
+    console.log('\n  Table triggers:');
+    for (const t of triggers) {
+      console.log(`    ${t.function} [${t.table}] — ${t.interval} every ${t.every}`);
+    }
+  }
+  process.exit(0);
+}
+
+// Auth enforcement
+const userProfile = await ensureAuthenticated(dbName, args, envConfig, env);
+
+if (args.remove) {
+  if (args.function) {
+    console.log(`Removing trigger "${args.function}" for ${dbName} (${env}, ${instance.type})...`);
+    const result = claspRun(distDir, 'ddlRemoveTrigger', [{ functionName: args.function }], { userProfile });
+    console.log('\nResult:', JSON.stringify(result, null, 2));
+  } else {
+    console.log(`Removing all triggers for ${dbName} (${env}, ${instance.type})...`);
+    const result = claspRun(distDir, 'ddlRemoveAllTriggers', [], { userProfile });
+    console.log('\nResult:', JSON.stringify(result, null, 2));
+  }
+} else {
+  const toSetup = args.function
+    ? triggers.filter(t => t.function === args.function)
+    : triggers;
+
+  if (toSetup.length === 0) {
+    if (args.function) {
+      console.error(`Trigger "${args.function}" not found in tables.json.`);
+      console.error(`Available: ${triggers.map(t => t.function).join(', ') || '(none)'}`);
+    } else {
+      console.log('No table triggers defined. Add "triggers" array to tables in tables.json.');
+    }
+    process.exit(0);
+  }
+
+  console.log(`Setting up ${toSetup.length} trigger(s) for ${dbName} (${env}, ${instance.type})...\n`);
+
+  for (const trigger of toSetup) {
+    const intervalMap = { minutes: 'everyMinutes', hours: 'everyHours', days: 'everyDays' };
+    const intervalType = intervalMap[trigger.interval] || 'everyHours';
+
+    console.log(`  ${trigger.function} [${trigger.table}]: ${trigger.interval} every ${trigger.every}`);
+    const result = claspRun(distDir, 'ddlSetupTrigger', [{
+      functionName: trigger.function,
+      intervalType,
+      interval: trigger.every
+    }], { userProfile });
+    console.log(`    → ${JSON.stringify(result)}`);
+  }
+
+  console.log('\nDone.');
+}