@supatype/cli 0.1.0-alpha.10

package/src/commands/push.ts

@@ -0,0 +1,226 @@
+import type { Command } from "commander"
+import { mkdirSync, writeFileSync } from "node:fs"
+import { createInterface } from "node:readline"
+import { join } from "node:path"
+import { loadConfig, loadSchemaAst } from "../config.js"
+import { connectionString, resolveRuntimeProvider, schemaPathFromProject, serverBaseUrl } from "../project-config.js"
+import { isCloudLinked, pushSchemaToLinkedProject } from "./cloud.js"
+import { ensureEngine, engineRequest, type DiffResult, type Operation } from "../engine-client.js"
+import { printDiffWarnings } from "../diff-output.js"
+import { signJwt } from "../jwt.js"
+import { provisionBuckets } from "../storage-provision.js"
+import { promptFirstAdminUser } from "./admin.js"
+import { withAdminRoles } from "../studio-admin-roles.js"
+import { restoreSystemRelationTargets } from "../restore-system-relation-targets.js"
+import type { SupatypeProjectConfig } from "../project-config.js"
+
+const DEV_JWT_SECRET = "super-secret-jwt-token-with-at-least-32-characters-long"
+
+export function registerPush(program: Command): void {
+  program
+    .command("push")
+    .description(
+      "Push schema to the database: diff, prompt for destructive changes, apply migration, generate types",
+    )
+    .option("--yes", "Skip confirmation prompts for destructive changes")
+    .option("--connection <url>", "Database connection URL (overrides config)")
+    .action(async (opts: { yes?: boolean; connection?: string }) => {
+      const cwd = process.cwd()
+
+      if (isCloudLinked(cwd)) {
+        if (opts.connection) {
+          console.error("--connection is not allowed when linked to a cloud project (credentials stay server-side).")
+          process.exit(1)
+        }
+        await pushSchemaToLinkedProject(cwd, { force: opts.yes ?? true })
+        return
+      }
+
+      const config = loadConfig(cwd)
+
+      // Docker provider: the compose Postgres isn't published to the host, so
+      // apply the schema through the in-compose schema-engine (unless the user
+      // gave an explicit --connection to a reachable database).
+      if (!opts.connection && resolveRuntimeProvider(config) === "docker") {
+        const { pushSchemaDocker } = await import("../dev-compose.js")
+        await pushSchemaDocker(cwd, config)
+        return
+      }
+
+      const connection = opts.connection ?? connectionString(config)
+
+      await ensureEngine()
+
+      console.log("Loading schema...")
+      const ast = loadSchemaAst(schemaPathFromProject(config, cwd), cwd)
+
+      console.log("Diffing against database...")
+      const diff = await engineRequest<DiffResult>("/diff", {
+        ast,
+        database_url: connection,
+        schema: "public",
+      })
+
+      const ops = diff.operations ?? []
+      printDiffWarnings(diff)
+
+      if (ops.length === 0) {
+        console.log(
+          "Schema matches the database (no DDL). Syncing Studio metadata...",
+        )
+      } else {
+        printDiff(ops)
+
+        const risky = ops.filter(
+          (o) => o.risk === "cautious" || o.risk === "destructive" || o.risk === "warn" || o.risk === "danger",
+        )
+        if (risky.length > 0 && !opts.yes) {
+          const confirmed = await confirm(
+            `\n${risky.length} risky operation(s) above (type changes or data loss). Proceed? [y/N] `,
+          )
+          if (!confirmed) {
+            console.log("Aborted.")
+            return
+          }
+        }
+      }
+
+      console.log(ops.length > 0 ? "\nApplying migration..." : "\nSyncing with engine...")
+      const pushResult = await engineRequest<{
+        message?: string
+        status?: string
+        admin_refreshed?: boolean
+      }>("/push", {
+        ast,
+        database_url: connection,
+        schema: "public",
+        force: true,
+      })
+      if (pushResult.status === "up_to_date") {
+        console.log(
+          pushResult.admin_refreshed
+            ? "Database schema unchanged — Studio metadata synced."
+            : "Schema is up to date.",
+        )
+      } else {
+        console.log(pushResult.message ?? "Migration applied.")
+      }
+
+      await writeLocalAdminConfig(ast, config)
+
+      // After a DDL migration, check if this is the first push and offer to create an
+      // admin user if none exist (Gap Appendices task 48).
+      if (ops.length > 0) {
+        await promptFirstAdminUser(connection)
+      }
+
+      // Provision storage buckets declared in the schema.
+      const baseUrl = serverBaseUrl(config)
+      const serviceRoleKey =
+        process.env["SUPATYPE_SERVICE_ROLE_KEY"] ??
+        (config.server.mode === "dev"
+          ? signJwt({ role: "service_role", iss: "supatype", iat: Math.floor(Date.now() / 1000) }, DEV_JWT_SECRET)
+          : undefined)
+
+      if (baseUrl && serviceRoleKey) {
+        const parsedAst = await engineRequest<{
+          storageBuckets?: Array<{
+            id: string
+            public: boolean
+            accessMode?: "public" | "private" | "custom"
+            allowedMimeTypes?: string[]
+            fileSizeLimit?: number
+            s3BucketPolicy?: string
+          }>
+        }>("/parse", { ast })
+        const buckets = (parsedAst.storageBuckets ?? []).map((b) => ({
+          id: b.id,
+          public: b.public,
+          ...(b.accessMode !== undefined && { access_mode: b.accessMode }),
+          ...(b.allowedMimeTypes != null && { allowed_mime_types: b.allowedMimeTypes }),
+          ...(b.fileSizeLimit != null && { file_size_limit: b.fileSizeLimit }),
+          ...(b.s3BucketPolicy != null &&
+            b.s3BucketPolicy !== "" && { s3_bucket_policy: b.s3BucketPolicy }),
+        }))
+        if (buckets.length > 0) {
+          console.log("Provisioning storage buckets...")
+          await provisionBuckets(`${baseUrl}/storage/v1`, serviceRoleKey, buckets)
+        }
+      }
+
+      if (config.output?.types ?? config.output?.client) {
+        console.log("Generating types...")
+        const genBody: Record<string, unknown> = { ast, lang: "typescript" }
+        if (config.output?.types) genBody["types_path"] = config.output.types
+        if (config.output?.client) genBody["client_path"] = config.output.client
+
+        const genResult = await engineRequest<{ code?: string; message?: string }>("/generate", genBody)
+        console.log(genResult.message ?? "Types generated.")
+      }
+
+      const studioBase = baseUrl?.replace(/\/$/, "") ?? ""
+      if (studioBase) {
+        console.log(`\nStudio: ${studioBase}/studio/ — sign in with the admin user you created.`)
+      } else {
+        console.log("\nDone.")
+      }
+    })
+}
+
+function printDiff(ops: Operation[]): void {
+  const symbol: Record<string, string> = {
+    safe: "+",
+    warn: "~",
+    cautious: "~",
+    danger: "!",
+    destructive: "!",
+  }
+  console.log(`\n${ops.length} change(s) planned:\n`)
+  for (const op of ops) {
+    const riskKey = op.risk ?? "safe"
+    const s = symbol[riskKey] ?? "?"
+    const label = op.warning ?? op.description ?? formatOperation(op)
+    console.log(`  [${s}] ${label}`)
+  }
+}
+
+function formatOperation(op: Operation): string {
+  if (typeof op.description === "string" && op.description.trim().length > 0) {
+    return op.description
+  }
+
+  const kind = typeof op.kind === "string" ? op.kind : "operation"
+  const raw = op as unknown as Record<string, unknown>
+  const table = raw["table"]
+  const column = raw["column"]
+
+  if (typeof table === "string" && typeof column === "string") {
+    return `${kind} ${table}.${column}`
+  }
+  if (typeof table === "string") {
+    return `${kind} ${table}`
+  }
+
+  // Last resort: show operation kind with compact payload.
+  return `${kind} ${JSON.stringify(op)}`
+}
+
+async function confirm(prompt: string): Promise<boolean> {
+  const rl = createInterface({ input: process.stdin, output: process.stdout })
+  return new Promise((resolve) => {
+    rl.question(prompt, (answer) => {
+      rl.close()
+      resolve(answer.toLowerCase() === "y")
+    })
+  })
+}
+
+/** Write `.supatype/admin-config.json` for local Studio (same layout as `supatype dev`). */
+async function writeLocalAdminConfig(ast: unknown, config: SupatypeProjectConfig): Promise<void> {
+  const cwd = process.cwd()
+  const dir = join(cwd, ".supatype")
+  mkdirSync(dir, { recursive: true })
+  const admin = withAdminRoles(await engineRequest<unknown>("/admin", { ast }), config)
+  restoreSystemRelationTargets(admin, ast)
+  writeFileSync(join(dir, "admin-config.json"), `${JSON.stringify(admin, null, 2)}\n`)
+}

package/src/commands/seed.ts

@@ -0,0 +1,68 @@
+import type { Command } from "commander"
+import { existsSync, readdirSync } from "node:fs"
+import { join, resolve } from "node:path"
+import { isLinkedToCloudProject } from "../binary-cache.js"
+import { loadConfig } from "../config.js"
+import { projectRootFromConfig } from "../project-config.js"
+import { runTsFile } from "../tsx-runner.js"
+
+const SEED_EXT = /\.(ts|mts|tsx)$/
+
+/** Seed entries under `seeds/`, sorted by filename (Phase 10.6 C19). */
+export function discoverSeedsDir(cwd: string, seedsDir: string): string[] {
+  if (!existsSync(seedsDir)) return []
+  const names = readdirSync(seedsDir).filter((n) => SEED_EXT.test(n))
+  names.sort((a, b) => a.localeCompare(b))
+  return names.map((n) => join(seedsDir, n))
+}
+
+export function registerSeed(program: Command): void {
+  program
+    .command("seed [file]")
+    .description(
+      "Run database seeds: optional single file; else all seeds/*.ts (alphabetical); else seed.ts",
+    )
+    .option(
+      "--force",
+      "Allow running when the project is linked to Supatype Cloud (dangerous)",
+      false,
+    )
+    .action(async (file: string | undefined, opts: { force: boolean }) => {
+      const cwd = process.cwd()
+      const config = loadConfig(cwd)
+      if (isLinkedToCloudProject(cwd, config) && !opts.force) {
+        console.error(
+          "[supatype] This project is linked to Supatype Cloud. Refusing to run seeds locally.\n" +
+            "  Pass --force only if you intend to target this linked project (advanced).",
+        )
+        process.exit(1)
+      }
+
+      const root = projectRootFromConfig(config, cwd)
+      const seedsDir = join(root, "seeds")
+
+      let paths: string[]
+      if (file !== undefined && file.trim() !== "") {
+        paths = [resolve(cwd, file)]
+      } else {
+        paths = discoverSeedsDir(cwd, seedsDir)
+        if (paths.length === 0) {
+          paths = [resolve(root, "seed.ts")]
+        }
+      }
+
+      const missing = paths.filter((p) => !existsSync(p))
+      if (missing.length > 0) {
+        console.error(`Seed file(s) not found:\n  ${missing.join("\n  ")}`)
+        process.exit(1)
+      }
+
+      for (const seedFile of paths) {
+        console.log(`[supatype] Running ${seedFile}...`)
+        const result = runTsFile(seedFile, { cwd, stdio: "inherit" })
+        if (result.exitCode !== 0) {
+          process.exit(result.exitCode)
+        }
+      }
+    })
+}

package/src/commands/self-host.ts

@@ -0,0 +1,364 @@
+/**
+ * self-host commands — manage self-hosted deployments.
+ *
+ * Compose-based commands are the canonical path.
+ * Native/systemd commands are kept temporarily for migration compatibility.
+ */
+
+import { Command } from "commander"
+import { existsSync, readFileSync, mkdirSync, copyFileSync, writeFileSync } from "node:fs"
+import { join, resolve } from "node:path"
+import { homedir } from "node:os"
+import { spawnSync } from "node:child_process"
+import { gzipSync } from "node:zlib"
+import { loadConfig } from "../config.js"
+import { connectionString } from "../project-config.js"
+import { resolveBinary } from "../binary-cache.js"
+import { generateUnits } from "../systemd.js"
+import { readPid } from "../process-manager.js"
+import { localStorageEnv } from "../local-storage.js"
+import { runDockerCompose, writeSelfHostCompose } from "../self-host-compose.js"
+
+export function registerSelfHost(program: Command): void {
+  const selfHostCmd = program
+    .command("self-host")
+    .description("Manage self-hosted deployments (Docker Compose only)")
+
+  const composeCmd = selfHostCmd
+    .command("compose")
+    .description("Manage compose-based self-host runtime")
+
+  composeCmd
+    .command("render")
+    .description("Render deterministic self-host compose artifacts")
+    .action(() => {
+      const cwd = process.cwd()
+      const config = loadConfig(cwd)
+      const out = writeSelfHostCompose(cwd, config)
+      console.log(`Wrote ${out.composePath}`)
+      console.log(`Wrote ${out.kongPath}`)
+    })
+
+  composeCmd
+    .command("up")
+    .description("Render and start compose services")
+    .option("-d, --detach", "Start in detached mode", true)
+    .action((opts: { detach?: boolean }) => {
+      const cwd = process.cwd()
+      const config = loadConfig(cwd)
+      const out = writeSelfHostCompose(cwd, config)
+      const status = runDockerCompose(out.composePath, opts.detach ? ["up", "-d"] : ["up"], cwd)
+      process.exitCode = status
+    })
+
+  composeCmd
+    .command("down")
+    .description("Stop compose services")
+    .action(() => {
+      const cwd = process.cwd()
+      const config = loadConfig(cwd)
+      const out = writeSelfHostCompose(cwd, config)
+      process.exitCode = runDockerCompose(out.composePath, ["down"], cwd)
+    })
+
+  composeCmd
+    .command("status")
+    .description("Show compose service status")
+    .action(() => {
+      const cwd = process.cwd()
+      const config = loadConfig(cwd)
+      const out = writeSelfHostCompose(cwd, config)
+      process.exitCode = runDockerCompose(out.composePath, ["ps"], cwd)
+    })
+
+  composeCmd
+    .command("logs")
+    .description("Tail compose logs")
+    .option("--service <name>", "Filter to one service")
+    .option("-f, --follow", "Follow log output", true)
+    .action((opts: { service?: string; follow?: boolean }) => {
+      const cwd = process.cwd()
+      const config = loadConfig(cwd)
+      const out = writeSelfHostCompose(cwd, config)
+      const args = ["logs"]
+      if (opts.follow) args.push("-f")
+      if (opts.service) args.push(opts.service)
+      process.exitCode = runDockerCompose(out.composePath, args, cwd)
+    })
+
+  // ── Legacy native/systemd helpers (hidden; use compose for self-host) ─────
+
+  const legacyCmd = new Command("native")
+  selfHostCmd.addCommand(legacyCmd, { hidden: true })
+
+  legacyCmd
+    .command(
+      "install-service",
+      "Generate systemd unit files and (on Linux) install + enable them",
+    )
+    .option("--output-dir <path>", "Write unit files here instead of /etc/systemd/system/")
+    .option("--user <name>", "User to run services as")
+    .option("--no-enable", "Generate unit files but do not enable/start them")
+    .action(
+      async (opts: {
+        outputDir?: string
+        user?: string
+        enable: boolean
+      }) => {
+        logLegacyWarning("install-service")
+        const cwd = process.cwd()
+        const config = loadConfig(cwd)
+
+        const systemdDir = opts.outputDir ?? ".supatype/systemd"
+        const absSystemdDir = resolve(cwd, systemdDir)
+
+        console.log("Generating systemd unit files...")
+        const { postgres, server } = generateUnits(config, cwd, {
+          outputDir: absSystemdDir,
+          ...(opts.user !== undefined && { user: opts.user }),
+        })
+        console.log(`  wrote ${postgres}`)
+        console.log(`  wrote ${server}`)
+
+        if (!opts.enable) {
+          console.log(
+            `\nTo install manually:\n` +
+            `  sudo cp ${postgres} /etc/systemd/system/\n` +
+            `  sudo cp ${server} /etc/systemd/system/\n` +
+            `  sudo systemctl daemon-reload\n` +
+            `  sudo systemctl enable --now supatype-postgres supatype-server`,
+          )
+          return
+        }
+
+        if (process.platform !== "linux") {
+          console.log(
+            "\nNote: systemd unit installation is only supported on Linux.\n" +
+            `Unit files are at ${absSystemdDir}/`,
+          )
+          return
+        }
+
+        // Install to /etc/systemd/system/
+        console.log("\nInstalling to /etc/systemd/system/ (requires sudo)...")
+        const units = [
+          { src: postgres, dest: "/etc/systemd/system/supatype-postgres.service" },
+          { src: server, dest: "/etc/systemd/system/supatype-server.service" },
+        ]
+        for (const { src, dest } of units) {
+          const cp = spawnSync("sudo", ["cp", src, dest], { stdio: "inherit" })
+          if (cp.status !== 0) {
+            console.error(`Failed to copy ${src} to ${dest}`)
+            process.exit(1)
+          }
+        }
+
+        const daemonReload = spawnSync("sudo", ["systemctl", "daemon-reload"], { stdio: "inherit" })
+        if (daemonReload.status !== 0) { process.exit(1) }
+
+        const enable = spawnSync(
+          "sudo",
+          ["systemctl", "enable", "--now", "supatype-postgres", "supatype-server"],
+          { stdio: "inherit" },
+        )
+        if (enable.status !== 0) { process.exit(1) }
+
+        console.log("\nServices installed and started.")
+        console.log("  supatype-postgres.service")
+        console.log("  supatype-server.service")
+      },
+    )
+
+  // ── serve ──────────────────────────────────────────────────────────────────
+
+  legacyCmd
+    .command("serve", "Start supatype-server in the foreground (for standalone mode)")
+    .option("--port <port>", "Override port from config")
+    .action(async (opts: { port?: string }) => {
+      logLegacyWarning("serve")
+      const cwd = process.cwd()
+      const config = loadConfig(cwd)
+
+      const serverBin = await resolveBinary("server", config)
+      const port = opts.port ?? String(config.server.port ?? 54321)
+
+      const args = [
+        "--port", port,
+        "--mode", config.server.mode,
+        ...(config.server.domain ? ["--domain", config.server.domain] : []),
+      ]
+
+      const stateDir = join(homedir(), ".supatype", "projects", config.project.name)
+      const storageEnv = config.storage?.provider !== "s3" ? localStorageEnv(stateDir) : {}
+
+      console.log(`Starting supatype-server on port ${port}...`)
+      const result = spawnSync(serverBin, args, {
+        stdio: "inherit",
+        cwd,
+        env: { ...process.env, ...storageEnv },
+      })
+      process.exitCode = result.status ?? 1
+    })
+
+  // ── reload ─────────────────────────────────────────────────────────────────
+
+  legacyCmd
+    .command("reload", "Reload the running supatype-server (SIGHUP for config reload)")
+    .action(() => {
+      logLegacyWarning("reload")
+      const cwd = process.cwd()
+      const config = loadConfig(cwd)
+      const stateDir = join(homedir(), ".supatype", "projects", config.project.name)
+      const pid = readPid(join(stateDir, "pid"), "server")
+
+      if (!pid) {
+        // Try systemctl if running as a service
+        if (process.platform === "linux") {
+          const result = spawnSync("systemctl", ["reload", "supatype-server"], { stdio: "inherit" })
+          process.exitCode = result.status ?? 1
+          return
+        }
+        console.error("Server does not appear to be running (no PID file found).")
+        process.exitCode = 1
+        return
+      }
+
+      try {
+        process.kill(pid, "SIGHUP")
+        console.log(`Sent SIGHUP to supatype-server (pid ${pid}).`)
+      } catch (err) {
+        console.error(`Failed to signal pid ${pid}:`, (err as Error).message)
+        process.exitCode = 1
+      }
+    })
+
+  // ── status ─────────────────────────────────────────────────────────────────
+
+  legacyCmd
+    .command("status", "Show running status of supatype services")
+    .action(() => {
+      logLegacyWarning("status")
+      const cwd = process.cwd()
+      const config = loadConfig(cwd)
+      const stateDir = join(homedir(), ".supatype", "projects", config.project.name)
+
+      console.log(`Project: ${config.project.name}\n`)
+
+      if (process.platform === "linux" && existsSync("/run/systemd/system")) {
+        // systemd is active
+        for (const svc of ["supatype-postgres", "supatype-server"]) {
+          const result = spawnSync("systemctl", ["status", "--no-pager", "--lines=0", svc], {
+            encoding: "utf8",
+          })
+          const active = result.stdout?.includes("active (running)") ? "running" : "stopped"
+          console.log(`  ${svc}: ${active}`)
+        }
+      } else {
+        // PID file check
+        const serverPid = readPid(join(stateDir, "pid"), "server")
+        const pgPid = readPid(join(stateDir, "pid"), "postgres")
+        console.log(`  postgres:          ${pgPid ? `running (pid ${pgPid})` : "stopped"}`)
+        console.log(`  supatype-server:   ${serverPid ? `running (pid ${serverPid})` : "stopped"}`)
+      }
+
+      const logDir = join(stateDir, "logs")
+      if (existsSync(logDir)) {
+        console.log(`\nLogs: ${logDir}`)
+      }
+    })
+
+  // ── logs ───────────────────────────────────────────────────────────────────
+
+  selfHostCmd
+    .command("logs", "Tail supatype service logs", { hidden: true })
+    .option("--service <name>", "Show logs for: postgres | server")
+    .option("--lines <n>", "Number of lines to show", "50")
+    .option("-f, --follow", "Follow log output")
+    .action((opts: { service?: string; lines: string; follow?: boolean }) => {
+      logLegacyWarning("logs")
+      const cwd = process.cwd()
+      const config = loadConfig(cwd)
+      const stateDir = join(homedir(), ".supatype", "projects", config.project.name)
+      const logDir = join(stateDir, "logs")
+
+      if (process.platform === "linux" && existsSync("/run/systemd/system")) {
+        const args = ["--no-pager", "--lines", opts.lines]
+        if (opts.follow) args.push("--follow")
+        if (opts.service) args.push(`-u`, `supatype-${opts.service}`)
+        else args.push("-u", "supatype-postgres", "-u", "supatype-server")
+        spawnSync("journalctl", args, { stdio: "inherit" })
+        return
+      }
+
+      // File-based logs
+      const targets: Array<{ label: string; file: string }> = []
+      if (!opts.service || opts.service === "postgres") {
+        targets.push({ label: "postgres", file: join(logDir, "postgres.log") })
+      }
+      if (!opts.service || opts.service === "server") {
+        targets.push({ label: "server", file: join(logDir, "server.log") })
+      }
+
+      for (const { label, file } of targets) {
+        if (!existsSync(file)) {
+          console.log(`[${label}] log file not found: ${file}`)
+          continue
+        }
+        if (opts.follow) {
+          const tail = spawnSync("tail", ["-f", "-n", opts.lines, file], { stdio: "inherit" })
+          process.exitCode = tail.status ?? 0
+        } else {
+          const n = parseInt(opts.lines, 10)
+          const content = readFileSync(file, "utf8")
+          const lines = content.split("\n")
+          console.log(lines.slice(-n).join("\n"))
+        }
+      }
+    })
+
+  // ── backup ─────────────────────────────────────────────────────────────────
+
+  legacyCmd
+    .command("backup", "Create a Postgres dump of the project database")
+    .option("--output <path>", "Output file path (default: ./backups/backup-<timestamp>.sql.gz)")
+    .option("--connection <url>", "Database connection URL (overrides config)")
+    .action((opts: { output?: string; connection?: string }) => {
+      logLegacyWarning("backup")
+      const cwd = process.cwd()
+      const config = loadConfig(cwd)
+      const conn = opts.connection ?? connectionString(config)
+      const outFile = opts.output ?? resolve(
+        cwd,
+        "backups",
+        `backup-${new Date().toISOString().replace(/[:.]/g, "-")}.sql.gz`,
+      )
+
+      mkdirSync(resolve(outFile, ".."), { recursive: true })
+
+      console.log(`Backing up database to ${outFile}...`)
+      try {
+        // Avoid shell interpolation of user-supplied values.
+        const pgDump = spawnSync("pg_dump", [conn], {
+          stdio: ["ignore", "pipe", "pipe"],
+        })
+        if (pgDump.status !== 0) {
+          const stderr = pgDump.stderr?.toString("utf8") ?? ""
+          throw new Error(stderr.trim() || "pg_dump failed")
+        }
+
+        const compressed = gzipSync(pgDump.stdout)
+        writeFileSync(outFile, compressed)
+        console.log("Backup complete.")
+      } catch (err) {
+        console.error("Backup failed:", (err as Error).message)
+        process.exit(1)
+      }
+    })
+}
+
+function logLegacyWarning(cmd: string): void {
+  console.warn(
+    `[supatype] self-host native ${cmd} is deprecated. ` +
+      "Use `supatype self-host compose` commands instead.",
+  )
+}