@slingr/cli 0.0.2 → 0.0.4

package/dist/templates/ops/cloudbuild.yaml.template

@@ -0,0 +1,161 @@
+# Cloud Build pipeline for {{APP_NAME}}
+# Triggered on push to the `develop` branch.
+#
+# Required substitutions (set in the Cloud Build trigger):
+#   _PROJECT_ID      GCP project ID
+#   _REGION          Cloud Run region (e.g. us-central1)
+#   _AR_REPO         Artifact Registry repo name
+#   _BACKEND_SERVICE Cloud Run backend service name
+#   _BACKEND_SA      Backend service account email
+#   _CLOUDSQL_INSTANCE  Full instance connection name (PROJECT:REGION:INSTANCE)
+#   _DB_SECRET_NAME  Secret Manager secret name for DB password
+#   _JWT_SECRET_NAME Secret Manager secret name for JWT signing key
+#   _FIREBASE_PROJECT Firebase / GCP project ID
+
+substitutions:
+  _REGION: us-central1
+  _AR_REPO: slingr-apps
+  _BACKEND_SERVICE: {{APP_NAME}}-backend
+
+options:
+  logging: CLOUD_LOGGING_ONLY
+
+steps:
+  # ── Backend ──────────────────────────────────────────────────────────────
+
+  - id: pull-backend-cache
+    name: gcr.io/cloud-builders/docker
+    entrypoint: bash
+    args:
+      - -c
+      - |
+        docker pull ${_REGION}-docker.pkg.dev/${_PROJECT_ID}/${_AR_REPO}/${_BACKEND_SERVICE}:latest \
+          || echo "No cache found, proceeding without it."
+
+  - id: build-backend
+    name: gcr.io/cloud-builders/docker
+    args:
+      - build
+      - --cache-from=${_REGION}-docker.pkg.dev/${_PROJECT_ID}/${_AR_REPO}/${_BACKEND_SERVICE}:latest
+      - -f
+      - backend/Dockerfile
+      - -t
+      - ${_REGION}-docker.pkg.dev/${_PROJECT_ID}/${_AR_REPO}/${_BACKEND_SERVICE}:$COMMIT_SHA
+      - -t
+      - ${_REGION}-docker.pkg.dev/${_PROJECT_ID}/${_AR_REPO}/${_BACKEND_SERVICE}:latest
+      - .
+    waitFor:
+      - pull-backend-cache
+
+  - id: push-backend
+    name: gcr.io/cloud-builders/docker
+    args:
+      - push
+      - --all-tags
+      - ${_REGION}-docker.pkg.dev/${_PROJECT_ID}/${_AR_REPO}/${_BACKEND_SERVICE}
+    waitFor:
+      - build-backend
+
+  # ── Schema sync (Cloud Run Job) ────────────────────────────────────────────
+  - id: schema-sync
+    name: gcr.io/google.com/cloudsdktool/cloud-sdk:alpine
+    entrypoint: bash
+    args:
+      - -c
+      - |
+        set -e
+        IMAGE="${_REGION}-docker.pkg.dev/${_PROJECT_ID}/${_AR_REPO}/${_BACKEND_SERVICE}:$COMMIT_SHA"
+        JOB_NAME="{{APP_NAME}}-migrate"
+
+        gcloud run jobs create "$$JOB_NAME" \
+          --image="$$IMAGE" \
+          --region=${_REGION} \
+          --service-account=${_BACKEND_SA} \
+          --add-cloudsql-instances=${_CLOUDSQL_INSTANCE} \
+          --set-secrets="DB_PASSWORD=${_DB_SECRET_NAME}:latest" \
+          --set-env-vars="DB_HOST=/cloudsql/${_CLOUDSQL_INSTANCE},DB_USER=postgres,DB_NAME={{APP_NAME}},DB_SYNCHRONIZE=true,NODE_ENV=migration" \
+          --max-retries=1 \
+          --project=${_PROJECT_ID} \
+          2>/dev/null \
+        || gcloud run jobs update "$$JOB_NAME" \
+          --image="$$IMAGE" \
+          --region=${_REGION} \
+          --service-account=${_BACKEND_SA} \
+          --add-cloudsql-instances=${_CLOUDSQL_INSTANCE} \
+          --set-secrets="DB_PASSWORD=${_DB_SECRET_NAME}:latest" \
+          --set-env-vars="DB_HOST=/cloudsql/${_CLOUDSQL_INSTANCE},DB_USER=postgres,DB_NAME={{APP_NAME}},DB_SYNCHRONIZE=true,NODE_ENV=migration" \
+          --max-retries=1 \
+          --project=${_PROJECT_ID}
+
+        gcloud run jobs execute "$$JOB_NAME" \
+          --region=${_REGION} \
+          --wait \
+          --project=${_PROJECT_ID}
+    waitFor:
+      - push-backend
+
+  # ── Deploy backend ─────────────────────────────────────────────────────────
+  - id: deploy-backend
+    name: gcr.io/google.com/cloudsdktool/cloud-sdk:alpine
+    entrypoint: gcloud
+    args:
+      - run
+      - deploy
+      - ${_BACKEND_SERVICE}
+      - --image=${_REGION}-docker.pkg.dev/${_PROJECT_ID}/${_AR_REPO}/${_BACKEND_SERVICE}:$COMMIT_SHA
+      - --region=${_REGION}
+      - --platform=managed
+      - --service-account=${_BACKEND_SA}
+      - --add-cloudsql-instances=${_CLOUDSQL_INSTANCE}
+      - --set-secrets=DB_PASSWORD=${_DB_SECRET_NAME}:latest,JWT_SECRET=${_JWT_SECRET_NAME}:latest
+      - --set-env-vars=DB_HOST=/cloudsql/${_CLOUDSQL_INSTANCE},DB_USER=postgres,DB_NAME={{APP_NAME}},DB_SYNCHRONIZE=false,NODE_ENV=production,HOST=0.0.0.0
+      - --allow-unauthenticated
+      - --project=${_PROJECT_ID}
+    waitFor:
+      - schema-sync
+
+  # ── Build & deploy frontend (Firebase Hosting) ─────────────────────────────
+  - id: build-frontend
+    name: node:20-alpine
+    entrypoint: sh
+    args:
+      - -c
+      - |
+        set -e
+        apk add --no-cache git
+
+        # Install app dependencies (framework comes from npm registry)
+        npm install
+
+        # Generate view registries, GraphQL schema & SDK types
+        npx slingr sync-metadata
+
+        # Build the frontend
+        cd frontend
+        npm ci
+        npm run build
+    waitFor:
+      - push-backend
+
+  - id: deploy-frontend
+    name: node:20-alpine
+    entrypoint: sh
+    args:
+      - -c
+      - |
+        set -e
+        npm install -g firebase-tools
+        firebase deploy --only hosting \
+          --project=${_FIREBASE_PROJECT} \
+          --non-interactive \
+          --token="$$FIREBASE_TOKEN"
+    secretEnv:
+      - FIREBASE_TOKEN
+    waitFor:
+      - build-frontend
+      - deploy-backend
+
+availableSecrets:
+  secretManager:
+    - versionName: projects/${_PROJECT_ID}/secrets/firebase-ci-token/versions/latest
+      env: FIREBASE_TOKEN

package/dist/templates/ops/scripts/_utils.js.template

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+
+const { spawn, spawnSync } = require('child_process');
+const net = require('net');
+const readline = require('readline');
+
+function escapeWindowsArg(arg) {
+  if (/^[A-Za-z0-9_./:-]+$/.test(arg)) {
+    return arg;
+  }
+
+  return `"${arg.replace(/"/g, '\\"')}"`;
+}
+
+function buildCommand(command, args = []) {
+  if (process.platform !== 'win32') {
+    return { command, args };
+  }
+
+  const fullCommand = [command, ...args.map(escapeWindowsArg)].join(' ');
+  return {
+    command: 'cmd.exe',
+    args: ['/d', '/s', '/c', fullCommand],
+  };
+}
+
+function run(command, args = [], options = {}) {
+  const {
+    allowFailure = false,
+    cwd,
+    env,
+    input,
+    suppressOutput = false,
+  } = options;
+
+  const stdio = suppressOutput
+    ? ['pipe', 'pipe', 'pipe']
+    : input !== undefined
+      ? ['pipe', 'inherit', 'inherit']
+      : 'inherit';
+
+  const executable = buildCommand(command, args);
+
+  const result = spawnSync(executable.command, executable.args, {
+    cwd,
+    env,
+    stdio,
+    encoding: 'utf8',
+    input,
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  if ((result.status ?? 1) !== 0 && !allowFailure) {
+    throw new Error(`Command failed (${result.status}): ${command} ${args.join(' ')}`);
+  }
+
+  return result;
+}
+
+function runCapture(command, args = [], options = {}) {
+  const { allowFailure = false, cwd, env } = options;
+
+  const executable = buildCommand(command, args);
+
+  const result = spawnSync(executable.command, executable.args, {
+    cwd,
+    env,
+    stdio: ['ignore', 'pipe', 'pipe'],
+    encoding: 'utf8',
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  if ((result.status ?? 1) !== 0) {
+    if (allowFailure) {
+      return '';
+    }
+
+    const stderr = (result.stderr || '').trim();
+    throw new Error(`Command failed (${result.status}): ${command} ${args.join(' ')}${stderr ? `\n${stderr}` : ''}`);
+  }
+
+  return (result.stdout || '').trim();
+}
+
+function step(label) {
+  console.log(`==> ${label}`);
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function waitForPort(host, port, timeoutMs = 15000, intervalMs = 1000) {
+  const start = Date.now();
+
+  return new Promise(async (resolve, reject) => {
+    while (Date.now() - start < timeoutMs) {
+      const connected = await new Promise(res => {
+        const socket = net.connect({ host, port });
+
+        socket.once('connect', () => {
+          socket.end();
+          res(true);
+        });
+
+        socket.once('error', () => {
+          socket.destroy();
+          res(false);
+        });
+      });
+
+      if (connected) {
+        resolve();
+        return;
+      }
+
+      await sleep(intervalMs);
+    }
+
+    reject(new Error(`Timed out waiting for ${host}:${port}`));
+  });
+}
+
+function prompt(message, options = {}) {
+  const { hidden = false } = options;
+
+  if (!hidden) {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    return new Promise(resolve => {
+      rl.question(message, answer => {
+        rl.close();
+        resolve(answer);
+      });
+    });
+  }
+
+  return new Promise((resolve, reject) => {
+    const stdin = process.stdin;
+    let value = '';
+
+    process.stdout.write(message);
+
+    const cleanup = () => {
+      stdin.removeListener('data', onData);
+      if (stdin.isTTY) {
+        stdin.setRawMode(false);
+      }
+      stdin.pause();
+      process.stdout.write('\n');
+    };
+
+    const onData = chunk => {
+      const char = chunk.toString('utf8');
+
+      if (char === '\u0003') {
+        cleanup();
+        reject(new Error('Prompt cancelled.'));
+        return;
+      }
+
+      if (char === '\r' || char === '\n') {
+        cleanup();
+        resolve(value);
+        return;
+      }
+
+      if (char === '\u0008' || char === '\u007f') {
+        value = value.slice(0, -1);
+        return;
+      }
+
+      value += char;
+    };
+
+    stdin.setEncoding('utf8');
+    stdin.resume();
+    if (stdin.isTTY) {
+      stdin.setRawMode(true);
+    }
+    stdin.on('data', onData);
+  });
+}
+
+function getProjectIdFromGcloud() {
+  return runCapture('gcloud', ['config', 'get-value', 'project'], { allowFailure: true });
+}
+
+function resolveCommand(command) {
+  if (process.platform === 'win32') {
+    return 'cmd.exe';
+  }
+
+  return command;
+}
+
+module.exports = {
+  getProjectIdFromGcloud,
+  prompt,
+  run,
+  runCapture,
+  sleep,
+  step,
+  waitForPort,
+  resolveCommand,
+  buildCommand,
+  spawn,
+};

package/dist/templates/ops/scripts/deploy.js.template

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+// deploy.js - Manual deployment of {{APP_NAME}} to GCP.
+// Mirrors the Cloud Build pipeline. Run from the app root directory.
+//
+// Prerequisites: setup-gcp.js + setup-secrets.js completed,
+//   gcloud init run, Docker running.
+//
+// Usage: node ops/scripts/deploy.js [git-tag]
+//   Override project or region: PROJECT_ID=my-project REGION=europe-west1 node ops/scripts/deploy.js
+
+const path = require('path');
+const { getProjectIdFromGcloud, run, runCapture, step } = require('./_utils');
+
+function main() {
+  const projectId = process.env.PROJECT_ID || getProjectIdFromGcloud();
+  const region = process.env.REGION || 'us-central1';
+
+  if (!projectId || projectId === '(unset)') {
+    throw new Error('No active GCP project. Run gcloud init first, or pass PROJECT_ID as an env var.');
+  }
+
+  const arRepo = 'slingr-apps';
+  const backendService = '{{APP_NAME}}-backend';
+  const backendSa = `{{APP_NAME}}-backend@${projectId}.iam.gserviceaccount.com`;
+  const cloudsqlInstance = `${projectId}:${region}:{{APP_NAME}}-db`;
+  const dbSecretName = '{{APP_NAME}}-db-password';
+  const jwtSecretName = '{{APP_NAME}}-jwt-secret';
+  const frontendBucket = `${projectId}-{{APP_NAME}}-frontend`;
+  const fwdRuleName = '{{APP_NAME}}-http-rule';
+
+  const appDir = path.resolve(__dirname, '..', '..');
+  const repoRoot = runCapture('git', ['rev-parse', '--show-toplevel'], { cwd: appDir });
+
+  // In a monorepo the app lives inside the framework repo — build the framework
+  // from source. In standalone mode the framework is already installed as an
+  // npm dependency so there is nothing to build.
+  const isMonorepo = repoRoot !== appDir;
+
+  const imageBase = `${region}-docker.pkg.dev/${projectId}/${arRepo}/${backendService}`;
+  const tag = process.argv[2] || runCapture('git', ['rev-parse', '--short', 'HEAD'], { cwd: appDir });
+
+  console.log(`==> Deploying {{APP_NAME}} (tag: ${tag})`);
+
+  step('Building framework and CLI...');
+  if (isMonorepo) {
+    run('pnpm', ['run', 'build:all'], { cwd: repoRoot });
+  } else {
+    console.log('    (standalone mode — framework installed as npm dependency, skipping)');
+  }
+
+  step('Generating metadata (views, GraphQL types)...');
+  run('npx', ['slingr', 'sync-metadata'], { cwd: appDir });
+
+  step('Building app (backend + frontend)...');
+  run('npm', ['run', 'build:all'], { cwd: appDir });
+
+  run('docker', ['pull', `${imageBase}:latest`], { allowFailure: true, suppressOutput: true });
+  run('docker', [
+    'build',
+    `--cache-from=${imageBase}:latest`,
+    '-f',
+    'backend/Dockerfile',
+    '-t',
+    `${imageBase}:${tag}`,
+    '-t',
+    `${imageBase}:latest`,
+    '.',
+  ], { cwd: appDir });
+  run('docker', ['push', `${imageBase}:${tag}`]);
+  run('docker', ['push', `${imageBase}:latest`]);
+
+  const jobName = '{{APP_NAME}}-migrate';
+  const migrateArgs = [
+    `--image=${imageBase}:${tag}`,
+    `--region=${region}`,
+    `--service-account=${backendSa}`,
+    `--set-cloudsql-instances=${cloudsqlInstance}`,
+    `--set-secrets=DB_PASSWORD=${dbSecretName}:latest`,
+    `--set-env-vars=DB_HOST=/cloudsql/${cloudsqlInstance},DB_USER=postgres,DB_NAME={{APP_NAME}},DB_SYNCHRONIZE=true,NODE_ENV=migration`,
+    '--max-retries=1',
+    `--project=${projectId}`,
+  ];
+
+  const jobExists = run(
+    'gcloud',
+    ['run', 'jobs', 'describe', jobName, `--region=${region}`, `--project=${projectId}`],
+    { allowFailure: true, suppressOutput: true }
+  ).status === 0;
+
+  if (jobExists) {
+    run('gcloud', ['run', 'jobs', 'update', jobName, ...migrateArgs]);
+  } else {
+    run('gcloud', ['run', 'jobs', 'create', jobName, ...migrateArgs]);
+  }
+
+  run('gcloud', ['run', 'jobs', 'execute', jobName, `--region=${region}`, '--wait', `--project=${projectId}`]);
+
+  run('gcloud', [
+    'run',
+    'deploy',
+    backendService,
+    `--image=${imageBase}:${tag}`,
+    `--region=${region}`,
+    '--platform=managed',
+    `--service-account=${backendSa}`,
+    `--add-cloudsql-instances=${cloudsqlInstance}`,
+    `--set-secrets=DB_PASSWORD=${dbSecretName}:latest,JWT_SECRET=${jwtSecretName}:latest`,
+    `--set-env-vars=DB_HOST=/cloudsql/${cloudsqlInstance},DB_PORT=5432,DB_USER=postgres,DB_NAME={{APP_NAME}},DB_SYNCHRONIZE=false,NODE_ENV=production,HOST=0.0.0.0`,
+    '--allow-unauthenticated',
+    `--project=${projectId}`,
+  ]);
+
+  run('gsutil', ['-m', 'rsync', '-r', '-d', 'frontend/dist', `gs://${frontendBucket}`], { cwd: appDir });
+
+  console.log('');
+  console.log('✓ Deployment complete.');
+  const backendUrl = runCapture('gcloud', [
+    'run',
+    'services',
+    'describe',
+    backendService,
+    `--region=${region}`,
+    `--project=${projectId}`,
+    '--format=value(status.url)',
+  ]);
+  const lbIp = runCapture('gcloud', [
+    'compute',
+    'forwarding-rules',
+    'describe',
+    fwdRuleName,
+    '--global',
+    '--format=value(IPAddress)',
+    `--project=${projectId}`,
+  ]);
+
+  console.log(`  Backend  : ${backendUrl}`);
+  console.log(`  Frontend : http://${lbIp}  (or your custom domain if configured)`);
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(`ERROR: ${error.message}`);
+  process.exit(1);
+}