@multiplatform.one/cli 2.0.0 → 2.1.5

package/bin/multiplatformOne.mjs

@@ -21,4 +21,4 @@
  * limitations under the License.
  */
 
-import '@multiplatform.one/cli/bin/multiplatformOne';
+import "@multiplatform.one/cli/bin/multiplatformOne";

package/lib/bin/multiplatformOne.mjs

@@ -1,16 +1,36 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
 // src/bin/multiplatformOne.ts
-import fs from "fs/promises";
-import fsSync from "fs";
-import inquirer from "inquirer";
-import os from "os";
-import path from "path";
-import { execa } from "execa";
-import { fileURLToPath } from "url";
+import fsSync from "node:fs";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import axios from "axios";
 import { program } from "commander";
+import dotenv from "dotenv";
+import { execa } from "execa";
+import inquirer from "inquirer";
+import ora from "ora";
+import pg from "pg";
+var availableBackends = [
+  "api",
+  "frappe"
+];
+var availablePlatforms = [
+  "electron",
+  "expo",
+  "keycloak",
+  "next",
+  "storybook",
+  "storybook-expo"
+];
 process.env.COOKIECUTTER = `sh ${path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../scripts/cookiecutter.sh")}`;
 program.name("multiplatform.one");
 program.version(JSON.parse(fsSync.readFileSync(path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../package.json"), "utf8"))?.version);
-program.command("init").option("-r, --remote <remote>", "the remote to use", "https://gitlab.com/bitspur/multiplatform.one/cookiecutter").option("-c, --checkout <branch>", "branch, tag or commit to checkout", "main").argument("[name]", "the name of the project", "").description("init multiplatform.one").action(async (name, options) => {
+program.command("init").option("-r, --remote <remote>", "the remote to use", "https://gitlab.com/bitspur/multiplatform.one/cookiecutter").option("-c, --checkout <branch>", "branch, tag or commit to checkout", "main").option("-p, --platforms <platforms>", "platforms to keep").option("-b, --backends <backends>", "backends to keep").argument("[name]", "the name of the project", "").description("init multiplatform.one").action(async (name, options) => {
+  let { backends, platforms } = options;
   if ((await execa("git", [
     "rev-parse",
     "--is-inside-work-tree"
@@ -28,9 +48,37 @@ program.command("init").option("-r, --remote <remote>", "the remote to use", "ht
       }
     ])).name;
   }
+  if (!backends) {
+    const backendsResult = (await inquirer.prompt([
+      {
+        message: "What backends are you using?",
+        name: "backends",
+        type: "checkbox",
+        choices: availableBackends.map((name2) => ({
+          name: name2
+        }))
+      }
+    ])).backends;
+    backends = backendsResult.join(",");
+  }
+  if (!platforms) {
+    const platformsResult = (await inquirer.prompt([
+      {
+        message: "What platforms are you using?",
+        name: "platforms",
+        type: "checkbox",
+        choices: availablePlatforms.map((name2) => ({
+          name: name2
+        }))
+      }
+    ])).platforms;
+    platforms = platformsResult.join(",");
+  }
   const cookieCutterConfig = {
     default_context: {
-      name
+      name,
+      platforms,
+      backends
     }
   };
   const cookieCutterConfigFile = path.join(await fs.mkdtemp(path.join(os.tmpdir(), "multiplatform-")), "config.json");
@@ -55,7 +103,34 @@ program.command("init").option("-r, --remote <remote>", "the remote to use", "ht
     });
   }
 });
-program.command("update").option("-r, --remote <remote>", "the remote to use", "https://gitlab.com/bitspur/multiplatform.one/cookiecutter").option("-c, --checkout <branch>", "branch, tag or commit to checkout", "main").description("update multiplatform.one").action(async (options) => {
+program.command("update").option("-r, --remote <remote>", "the remote to use", "https://gitlab.com/bitspur/multiplatform.one/cookiecutter").option("-c, --checkout <branch>", "branch, tag or commit to checkout", "main").option("-p, --platforms <platforms>", "platforms to keep").option("-b, --backends <backends>", "backends to keep").description("update multiplatform.one").action(async (options) => {
+  let { backends, platforms } = options;
+  if (!backends) {
+    const backendsResult = await inquirer.prompt([
+      {
+        message: "What backends are you using?",
+        name: "backends",
+        type: "checkbox",
+        choices: availableBackends.map((name) => ({
+          name
+        }))
+      }
+    ]);
+    backends = backendsResult.backends.join(",");
+  }
+  if (!platforms) {
+    const platformsResult = await inquirer.prompt([
+      {
+        message: "What platforms are you using?",
+        name: "platforms",
+        type: "checkbox",
+        choices: availablePlatforms.map((name) => ({
+          name
+        }))
+      }
+    ]);
+    platforms = platformsResult.platforms.join(",");
+  }
   if ((await execa("git", [
     "rev-parse",
     "--is-inside-work-tree"
@@ -80,11 +155,15 @@ program.command("update").option("-r, --remote <remote>", "the remote to use", "
   let cookieCutterConfig;
   if ((await fs.stat(path.resolve(projectRoot, "package.json"))).isFile() && (await fs.stat(path.resolve(projectRoot, "app/package.json"))).isFile() && JSON.parse(await fs.readFile(path.resolve(projectRoot, "app/package.json"), "utf8"))?.dependencies?.["multiplatform.one"]?.length) {
     const name = JSON.parse(await fs.readFile(path.resolve(projectRoot, "package.json"), "utf8"))?.name;
-    if (name) cookieCutterConfig = {
-      default_context: {
-        name
-      }
-    };
+    if (name) {
+      cookieCutterConfig = {
+        default_context: {
+          name,
+          backends,
+          platforms
+        }
+      };
+    }
   }
   if (!cookieCutterConfig) throw new Error("not a multiplatform.one project");
   const cookieCutterConfigFile = path.join(await fs.mkdtemp(path.join(os.tmpdir(), "multiplatform-")), "config.json");
@@ -110,4 +189,137 @@ program.command("update").option("-r, --remote <remote>", "the remote to use", "
     });
   }
 });
+var waitServices = [
+  "api",
+  "frappe",
+  "postgres",
+  "keycloak"
+];
+program.command("wait").description("wait for a service to be ready").option("-i, --interval <interval>", "interval to wait for", 1e3).option("-t, --timeout <timeout>", "timeout to wait for", 6e5).option("-e, --dotenv <dotenv>", "dotenv file path", ".env").argument("<services>", `the services to wait for (${waitServices.join(", ")})`).action(async (servicesString, options) => {
+  dotenv.config({
+    path: options.dotenv
+  });
+  const interval = Number.parseInt(options.interval);
+  const timeout = Number.parseInt(options.timeout);
+  const services = servicesString.split(",");
+  const unreadyServices = [
+    ...services
+  ];
+  const spinner = ora(`waiting for ${formatServiceList(unreadyServices)}`).start();
+  function updateSpinner(readyService) {
+    unreadyServices.splice(unreadyServices.indexOf(readyService), 1);
+    spinner.stop();
+    spinner.succeed(`${readyService} is ready`);
+    if (!unreadyServices.length) return;
+    spinner.start(`waiting for ${formatServiceList(unreadyServices)}`);
+  }
+  __name(updateSpinner, "updateSpinner");
+  let timeoutId;
+  try {
+    await Promise.race([
+      Promise.all(services.map(async (service) => {
+        switch (service) {
+          case "api": {
+            await waitForApi(interval);
+            updateSpinner("api");
+            return;
+          }
+          case "frappe": {
+            await waitForFrappe(interval);
+            updateSpinner("frappe");
+            return;
+          }
+          case "postgres": {
+            await waitForPostgres(interval);
+            updateSpinner("postgres");
+            return;
+          }
+          case "keycloak": {
+            await waitForKeycloak(interval);
+            updateSpinner("keycloak");
+            return;
+          }
+        }
+        ora(`available services are ${formatServiceList(waitServices)}`).fail();
+      })),
+      new Promise((_, reject) => {
+        timeoutId = setTimeout(() => reject(new Error("Timeout")), timeout);
+      })
+    ]);
+  } catch (err) {
+    if (err instanceof Error && err.message === "Timeout") {
+      spinner.fail(`${formatServiceList(unreadyServices)} timed out after ${timeout}ms`);
+    } else {
+      spinner.fail(err);
+    }
+    process.exit(1);
+  } finally {
+    clearTimeout(timeoutId);
+  }
+});
+function formatServiceList(services) {
+  if (services.length === 1) return services[0];
+  if (services.length === 2) return `${services[0]} and ${services[1]}`;
+  return `${services.slice(0, -1).join(", ")} and ${services[services.length - 1]}`;
+}
+__name(formatServiceList, "formatServiceList");
 program.parse(process.argv);
+async function waitForApi(interval) {
+  try {
+    const res = await axios.get(`http://localhost:${process.env.API_PORT || "5001"}/healthz`);
+    if ((res?.status || 500) < 300) {
+      return;
+    }
+  } catch (err) {
+  }
+  await new Promise((resolve) => setTimeout(resolve, interval));
+  return waitForApi(interval);
+}
+__name(waitForApi, "waitForApi");
+async function waitForFrappe(interval) {
+  try {
+    const res = await axios.get(`${process.env.FRAPPE_BASE_URL || "http://frappe.localhost"}/api/method/ping`);
+    if ((res?.status || 500) < 300) {
+      return;
+    }
+  } catch (err) {
+  }
+  await new Promise((resolve) => setTimeout(resolve, interval));
+  return waitForFrappe(interval);
+}
+__name(waitForFrappe, "waitForFrappe");
+async function waitForPostgres(interval) {
+  const client = new pg.Client({
+    database: process.env.POSTGRES_DATABASE || "postgres",
+    host: process.env.POSTGRES_HOSTNAME || "localhost",
+    password: process.env.POSTGRES_PASSWORD || "postgres",
+    port: Number.parseInt(process.env.POSTGRES_PORT || "5432"),
+    user: process.env.POSTGRES_USERNAME || "postgres"
+  });
+  try {
+    await client.connect();
+    while (true) {
+      try {
+        await client.query("SELECT 1");
+        return;
+      } catch (error) {
+      }
+      await new Promise((resolve) => setTimeout(resolve, interval));
+    }
+  } finally {
+    await client.end();
+  }
+}
+__name(waitForPostgres, "waitForPostgres");
+async function waitForKeycloak(interval) {
+  try {
+    const res = await axios.get(`${process.env.KEYCLOAK_BASE_URL || "http://localhost:8080"}/realms/master/.well-known/openid-configuration`);
+    if ((res?.status || 500) < 300) {
+      return;
+    }
+  } catch (err) {
+  }
+  await new Promise((resolve) => setTimeout(resolve, interval));
+  return waitForKeycloak(interval);
+}
+__name(waitForKeycloak, "waitForKeycloak");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@multiplatform.one/cli",
-  "version": "2.0.0",
+  "version": "2.1.5",
   "author": "BitSpur <support@bitspur.com> (https://bitspur.com)",
   "contributors": [
     {
@@ -48,16 +48,20 @@
     "node": ">= 16.0"
   },
   "devDependencies": {
+    "@multiplatform.one/utils": "0.1.6",
     "@types/inquirer": "^9.0.7",
     "@types/node": "~20.12.13",
-    "tsup": "^8.1.0",
-    "typescript": "~5.3.3",
-    "@multiplatform.one/utils": "^1.0.0"
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.2"
   },
   "dependencies": {
+    "axios": "^1.7.7",
     "commander": "^9.5.0",
-    "execa": "^9.2.0",
-    "inquirer": "^9.2.23"
+    "dotenv": "^16.4.5",
+    "execa": "^9.4.1",
+    "inquirer": "^9.3.7",
+    "ora": "^8.1.0",
+    "pg": "^8.13.0"
   },
   "transpileModules": [
     "#ansi-styles",

package/src/bin/multiplatformOne.ts

@@ -1,10 +1,10 @@
-/*
+/**
  * File: /src/bin/multiplatformOne.ts
  * Project: @multiplatform.one/cli
- * File Created: 22-06-2024 14:17:12
+ * File Created: 01-01-1970 00:00:00
  * Author: Clay Risser
  * -----
- * BitSpur Copyright 2021 - 2024
+ * BitSpur (c) Copyright 2021 - 2024
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,63 +19,144 @@
  * limitations under the License.
  */
 
-import fs from 'fs/promises';
-import fsSync from 'fs';
-import inquirer from 'inquirer';
-import os from 'os';
-import path from 'path';
-import type { CookieCutterConfig } from '../types';
-import { execa } from 'execa';
-import { fileURLToPath } from 'url';
-import { program } from 'commander';
+import fsSync from "node:fs";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import axios from "axios";
+import { program } from "commander";
+import dotenv from "dotenv";
+import { execa } from "execa";
+import inquirer from "inquirer";
+import ora from "ora";
+import pg from "pg";
+import type { CookieCutterConfig } from "../types";
 
-process.env.COOKIECUTTER = `sh ${path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../scripts/cookiecutter.sh')}`;
-program.name('multiplatform.one');
+const availableBackends = ["api", "frappe"];
+const availablePlatforms = [
+  "electron",
+  "expo",
+  "keycloak",
+  "next",
+  "storybook",
+  "storybook-expo",
+];
+
+process.env.COOKIECUTTER = `sh ${path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "../../scripts/cookiecutter.sh",
+)}`;
+program.name("multiplatform.one");
 program.version(
   JSON.parse(
-    fsSync.readFileSync(path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../package.json'), 'utf8'),
+    fsSync.readFileSync(
+      path.resolve(
+        path.dirname(fileURLToPath(import.meta.url)),
+        "../../package.json",
+      ),
+      "utf8",
+    ),
   )?.version,
 );
 
 program
-  .command('init')
-  .option('-r, --remote <remote>', 'the remote to use', 'https://gitlab.com/bitspur/multiplatform.one/cookiecutter')
-  .option('-c, --checkout <branch>', 'branch, tag or commit to checkout', 'main')
-  .argument('[name]', 'the name of the project', '')
-  .description('init multiplatform.one')
+  .command("init")
+  .option(
+    "-r, --remote <remote>",
+    "the remote to use",
+    "https://gitlab.com/bitspur/multiplatform.one/cookiecutter",
+  )
+  .option(
+    "-c, --checkout <branch>",
+    "branch, tag or commit to checkout",
+    "main",
+  )
+  .option("-p, --platforms <platforms>", "platforms to keep")
+  .option("-b, --backends <backends>", "backends to keep")
+  .argument("[name]", "the name of the project", "")
+  .description("init multiplatform.one")
   .action(async (name, options) => {
-    if ((await execa('git', ['rev-parse', '--is-inside-work-tree'], { reject: false })).exitCode === 0) {
-      throw new Error('multiplatform.one cannot be initialized inside a git repository');
+    let { backends, platforms } = options;
+
+    if (
+      (
+        await execa("git", ["rev-parse", "--is-inside-work-tree"], {
+          reject: false,
+        })
+      ).exitCode === 0
+    ) {
+      throw new Error(
+        "multiplatform.one cannot be initialized inside a git repository",
+      );
     }
     if (!name) {
       name = (
         await inquirer.prompt([
           {
-            message: 'What is the project name?',
-            name: 'name',
-            type: 'input',
+            message: "What is the project name?",
+            name: "name",
+            type: "input",
           },
         ])
       ).name;
     }
-    const cookieCutterConfig: CookieCutterConfig = { default_context: { name } };
-    const cookieCutterConfigFile = path.join(await fs.mkdtemp(path.join(os.tmpdir(), 'multiplatform-')), 'config.json');
+    if (!backends) {
+      const backendsResult = (
+        await inquirer.prompt([
+          {
+            message: "What backends are you using?",
+            name: "backends",
+            type: "checkbox",
+            choices: availableBackends.map((name) => ({ name })),
+          },
+        ])
+      ).backends;
+
+      backends = backendsResult.join(",");
+    }
+    if (!platforms) {
+      const platformsResult = (
+        await inquirer.prompt([
+          {
+            message: "What platforms are you using?",
+            name: "platforms",
+            type: "checkbox",
+            choices: availablePlatforms.map((name) => ({ name })),
+          },
+        ])
+      ).platforms;
+      platforms = platformsResult.join(",");
+    }
+    const cookieCutterConfig: CookieCutterConfig = {
+      default_context: { name, platforms, backends },
+    };
+    const cookieCutterConfigFile = path.join(
+      await fs.mkdtemp(path.join(os.tmpdir(), "multiplatform-")),
+      "config.json",
+    );
     try {
-      await fs.writeFile(cookieCutterConfigFile, JSON.stringify(cookieCutterConfig, null, 2));
+      await fs.writeFile(
+        cookieCutterConfigFile,
+        JSON.stringify(cookieCutterConfig, null, 2),
+      );
       await execa(
-        'sh',
+        "sh",
         [
-          path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../scripts/init.sh'),
-          '--no-input',
-          '-f',
-          '--config-file',
+          path.resolve(
+            path.dirname(fileURLToPath(import.meta.url)),
+            "../../scripts/init.sh",
+          ),
+          "--no-input",
+          "-f",
+          "--config-file",
           cookieCutterConfigFile,
-          '--checkout',
+          "--checkout",
           options.checkout,
           options.remote,
         ],
         {
-          stdio: 'inherit',
+          stdio: "inherit",
         },
       );
     } finally {
@@ -84,54 +165,115 @@ program
   });
 
 program
-  .command('update')
-  .option('-r, --remote <remote>', 'the remote to use', 'https://gitlab.com/bitspur/multiplatform.one/cookiecutter')
-  .option('-c, --checkout <branch>', 'branch, tag or commit to checkout', 'main')
-  .description('update multiplatform.one')
+  .command("update")
+  .option(
+    "-r, --remote <remote>",
+    "the remote to use",
+    "https://gitlab.com/bitspur/multiplatform.one/cookiecutter",
+  )
+  .option(
+    "-c, --checkout <branch>",
+    "branch, tag or commit to checkout",
+    "main",
+  )
+  .option("-p, --platforms <platforms>", "platforms to keep")
+  .option("-b, --backends <backends>", "backends to keep")
+  .description("update multiplatform.one")
   .action(async (options) => {
-    if ((await execa('git', ['rev-parse', '--is-inside-work-tree'], { reject: false })).exitCode !== 0) {
-      throw new Error('multiplatform.one cannot be updated outside of a git repository');
+    let { backends, platforms } = options;
+    if (!backends) {
+      const backendsResult = await inquirer.prompt([
+        {
+          message: "What backends are you using?",
+          name: "backends",
+          type: "checkbox",
+          choices: availableBackends.map((name) => ({ name })),
+        },
+      ]);
+      backends = backendsResult.backends.join(",");
+    }
+    if (!platforms) {
+      const platformsResult = await inquirer.prompt([
+        {
+          message: "What platforms are you using?",
+          name: "platforms",
+          type: "checkbox",
+          choices: availablePlatforms.map((name) => ({ name })),
+        },
+      ]);
+      platforms = platformsResult.platforms.join(",");
+    }
+    if (
+      (
+        await execa("git", ["rev-parse", "--is-inside-work-tree"], {
+          reject: false,
+        })
+      ).exitCode !== 0
+    ) {
+      throw new Error(
+        "multiplatform.one cannot be updated outside of a git repository",
+      );
     }
     if (
       (
-        await execa('git', ['diff', '--cached', '--quiet'], {
+        await execa("git", ["diff", "--cached", "--quiet"], {
           reject: false,
         })
       ).exitCode !== 0
     ) {
-      throw new Error('multiplatform.one cannot be updated with uncommitted changes');
+      throw new Error(
+        "multiplatform.one cannot be updated with uncommitted changes",
+      );
     }
-    const projectRoot = (await execa('git', ['rev-parse', '--show-toplevel'])).stdout.trim();
+    const projectRoot = (
+      await execa("git", ["rev-parse", "--show-toplevel"])
+    ).stdout.trim();
     let cookieCutterConfig: CookieCutterConfig | undefined;
     if (
-      (await fs.stat(path.resolve(projectRoot, 'package.json'))).isFile() &&
-      (await fs.stat(path.resolve(projectRoot, 'app/package.json'))).isFile() &&
-      JSON.parse(await fs.readFile(path.resolve(projectRoot, 'app/package.json'), 'utf8'))?.dependencies?.[
-        'multiplatform.one'
-      ]?.length
+      (await fs.stat(path.resolve(projectRoot, "package.json"))).isFile() &&
+      (await fs.stat(path.resolve(projectRoot, "app/package.json"))).isFile() &&
+      JSON.parse(
+        await fs.readFile(
+          path.resolve(projectRoot, "app/package.json"),
+          "utf8",
+        ),
+      )?.dependencies?.["multiplatform.one"]?.length
     ) {
-      const name = JSON.parse(await fs.readFile(path.resolve(projectRoot, 'package.json'), 'utf8'))?.name;
-      if (name) cookieCutterConfig = { default_context: { name } };
+      const name = JSON.parse(
+        await fs.readFile(path.resolve(projectRoot, "package.json"), "utf8"),
+      )?.name;
+      if (name) {
+        cookieCutterConfig = { default_context: { name, backends, platforms } };
+      }
     }
-    if (!cookieCutterConfig) throw new Error('not a multiplatform.one project');
-    const cookieCutterConfigFile = path.join(await fs.mkdtemp(path.join(os.tmpdir(), 'multiplatform-')), 'config.json');
+    if (!cookieCutterConfig) throw new Error("not a multiplatform.one project");
+    const cookieCutterConfigFile = path.join(
+      await fs.mkdtemp(path.join(os.tmpdir(), "multiplatform-")),
+      "config.json",
+    );
     try {
-      await fs.writeFile(cookieCutterConfigFile, JSON.stringify(cookieCutterConfig, null, 2));
+      await fs.writeFile(
+        cookieCutterConfigFile,
+        JSON.stringify(cookieCutterConfig, null, 2),
+      );
       await execa(
-        'sh',
+        "sh",
         [
-          path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../scripts/update.sh'),
-          '--no-input',
-          '-f',
-          '--config-file',
+          path.resolve(
+            path.dirname(fileURLToPath(import.meta.url)),
+            "../../scripts/update.sh",
+          ),
+          "--no-input",
+          "-f",
+          "--config-file",
           cookieCutterConfigFile,
-          '--checkout',
+          "--checkout",
           options.checkout,
           options.remote,
         ],
         {
           cwd: projectRoot,
-          stdio: 'inherit',
+          stdio: "inherit",
         },
       );
     } finally {
@@ -139,4 +281,148 @@ program
     }
   });
 
+const waitServices = ["api", "frappe", "postgres", "keycloak"];
+program
+  .command("wait")
+  .description("wait for a service to be ready")
+  .option("-i, --interval <interval>", "interval to wait for", 1000)
+  .option("-t, --timeout <timeout>", "timeout to wait for", 600000)
+  .option("-e, --dotenv <dotenv>", "dotenv file path", ".env")
+  .argument(
+    "<services>",
+    `the services to wait for (${waitServices.join(", ")})`,
+  )
+  .action(async (servicesString, options) => {
+    dotenv.config({ path: options.dotenv });
+    const interval = Number.parseInt(options.interval);
+    const timeout = Number.parseInt(options.timeout);
+    const services: string[] = servicesString.split(",");
+    const unreadyServices = [...services];
+    const spinner = ora(
+      `waiting for ${formatServiceList(unreadyServices)}`,
+    ).start();
+    function updateSpinner(readyService: string) {
+      unreadyServices.splice(unreadyServices.indexOf(readyService), 1);
+      spinner.stop();
+      spinner.succeed(`${readyService} is ready`);
+      if (!unreadyServices.length) return;
+      spinner.start(`waiting for ${formatServiceList(unreadyServices)}`);
+    }
+    let timeoutId: NodeJS.Timeout;
+    try {
+      await Promise.race([
+        Promise.all(
+          services.map(async (service) => {
+            switch (service) {
+              case "api": {
+                await waitForApi(interval);
+                updateSpinner("api");
+                return;
+              }
+              case "frappe": {
+                await waitForFrappe(interval);
+                updateSpinner("frappe");
+                return;
+              }
+              case "postgres": {
+                await waitForPostgres(interval);
+                updateSpinner("postgres");
+                return;
+              }
+              case "keycloak": {
+                await waitForKeycloak(interval);
+                updateSpinner("keycloak");
+                return;
+              }
+            }
+            ora(
+              `available services are ${formatServiceList(waitServices)}`,
+            ).fail();
+          }),
+        ),
+        new Promise((_, reject) => {
+          timeoutId = setTimeout(() => reject(new Error("Timeout")), timeout);
+        }),
+      ]);
+    } catch (err) {
+      if (err instanceof Error && err.message === "Timeout") {
+        spinner.fail(
+          `${formatServiceList(unreadyServices)} timed out after ${timeout}ms`,
+        );
+      } else {
+        spinner.fail(err);
+      }
+      process.exit(1);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  });
+
+function formatServiceList(services: string[]): string {
+  if (services.length === 1) return services[0];
+  if (services.length === 2) return `${services[0]} and ${services[1]}`;
+  return `${services.slice(0, -1).join(", ")} and ${services[services.length - 1]}`;
+}
+
 program.parse(process.argv);
+
+async function waitForApi(interval: number) {
+  try {
+    const res = await axios.get(
+      `http://localhost:${process.env.API_PORT || "5001"}/healthz`,
+    );
+    if ((res?.status || 500) < 300) {
+      return;
+    }
+  } catch (err) {}
+  await new Promise((resolve) => setTimeout(resolve, interval));
+  return waitForApi(interval);
+}
+
+async function waitForFrappe(interval: number) {
+  try {
+    const res = await axios.get(
+      `${process.env.FRAPPE_BASE_URL || "http://frappe.localhost"}/api/method/ping`,
+    );
+    if ((res?.status || 500) < 300) {
+      return;
+    }
+  } catch (err) {}
+  await new Promise((resolve) => setTimeout(resolve, interval));
+  return waitForFrappe(interval);
+}
+
+async function waitForPostgres(interval: number) {
+  const client = new pg.Client({
+    database: process.env.POSTGRES_DATABASE || "postgres",
+    host: process.env.POSTGRES_HOSTNAME || "localhost",
+    password: process.env.POSTGRES_PASSWORD || "postgres",
+    port: Number.parseInt(process.env.POSTGRES_PORT || "5432"),
+    user: process.env.POSTGRES_USERNAME || "postgres",
+  });
+  try {
+    await client.connect();
+    while (true) {
+      try {
+        await client.query("SELECT 1");
+        return;
+      } catch (error) {}
+      await new Promise((resolve) => setTimeout(resolve, interval));
+    }
+  } finally {
+    await client.end();
+  }
+}
+
+async function waitForKeycloak(interval: number) {
+  try {
+    const res = await axios.get(
+      `${process.env.KEYCLOAK_BASE_URL || "http://localhost:8080"}/realms/master/.well-known/openid-configuration`,
+    );
+    if ((res?.status || 500) < 300) {
+      return;
+    }
+  } catch (err) {}
+  await new Promise((resolve) => setTimeout(resolve, interval));
+  return waitForKeycloak(interval);
+}

package/src/index.ts

@@ -19,4 +19,4 @@
  * limitations under the License.
  */
 
-export {};
+export type {};

package/src/types.ts

@@ -21,6 +21,8 @@
 
 export interface CookieCutterConfig {
   default_context: {
+    backends: string;
     name: string;
+    platforms: string;
   };
 }

package/lib/bin/multiplatformOne.d.mts

@@ -1,2 +0,0 @@
-
-export {  }

package/lib/index.d.mts

@@ -1,2 +0,0 @@
-
-export {  }

package/lib/types.d.mts

@@ -1,7 +0,0 @@
-interface CookieCutterConfig {
-    default_context: {
-        name: string;
-    };
-}
-
-export type { CookieCutterConfig };