feat: Add incloud cli (#25)

Author: eveffer

README.md

@@ -40,7 +40,7 @@ _Reality is your canvas_
 
 </div>
 
-## 
+##
 
 <div align="center">
 
@@ -126,28 +126,24 @@ InSpatial Cloud is released under the Apache 2.0 License. See the
 
 ### Installation
 
-Add the InSpatial Cloud module to your Deno project using the following command:
+Install the InSpatial Cloud CLI:
 
 ```shell
-deno add jsr:@inspatial/cloud
+deno install -g jsr:@inspatial/cloud/incloud
 ```
 
-## Usage
+initialize a new project
 
-### Basic Usage
-
-```ts
-import { createInCloud } from "@inspatial/cloud";
-
-createInCloud();
+```shell
+incloud init myProject
 ```
+This will create a folder in the current directory with a started project.
 
-That's it! Now you can run the app:
+Now you can run your InSpatial Cloud project:
 
 ```shell
-deno run -A main.ts
+cd my-project
+incloud run main.ts
 ```
 
-You can verify the app is running by pinging the API endpoint in you browser:
-
-[http://localhost:8000/api?group=api&action=ping](http://localhost:8000/api?group=api&action=ping)
+You can verify the app is running by navigating to [http://localhost:8000](http://localhost:8000) in your browser

cli/incloud.ts

@@ -0,0 +1,145 @@
+import { InLog } from "~/in-log/in-log.ts";
+import { RunManager } from "./src/run-manager.ts";
+import convertString from "~/utils/convert-string.ts";
+import { center } from "~/terminal/format-utils.ts";
+
+const inLog = new InLog({
+  consoleDefaultStyle: "compact",
+  name: "InSpatial CLI",
+  traceOffset: 1,
+});
+function parseArgs() {
+  let command: string | undefined;
+  let lastArg: string | undefined;
+  const args: string[] = [];
+  Deno.args.forEach((arg, index) => {
+    if (index === 0) {
+      command = arg;
+      return; // Skip the first argument which is the command
+    }
+    if (index === Deno.args.length - 1) {
+      lastArg = arg; // Last argument is the file
+      return;
+    }
+    args.push(arg);
+  });
+
+  const file = lastArg;
+  return {
+    command,
+    file,
+    args,
+  };
+}
+
+function makeMainFile(projectName: string) {
+  const mainfile = `import { createInCloud } from "@inspatial/cloud";
+
+createInCloud({
+  name: "${projectName}",
+  description: "My InCloud Project",
+  entryTypes: [], // Define your entry types here
+  settingsTypes: [], // Define your settings types here
+  actionGroups: [], // Define your API action groups here
+});
+
+`;
+  return mainfile;
+}
+
+function doRun(rootPath: string, file?: string) {
+  inLog.info("Running InCloud project...");
+  const runner = new RunManager(rootPath, file);
+  runner.init();
+}
+
+function doInit(_rootPath: string, projectName?: string) {
+  if (!projectName) {
+    inLog.warn("Project name is required for initialization.");
+    Deno.exit(1);
+  }
+  const folderName = convertString(projectName, "kebab", true);
+  const name = convertString(folderName, "title", true);
+  inLog.warn(`Initializing project: ${name}`);
+
+  // Create the project directory
+  try {
+    Deno.mkdirSync(folderName);
+  } catch (e) {
+    if (e instanceof Deno.errors.AlreadyExists) {
+      inLog.error(`Project directory ${folderName} already exists.`);
+      Deno.exit(1);
+    }
+  }
+  Deno.chdir(folderName);
+  Deno.writeTextFileSync(
+    "deno.json",
+    JSON.stringify(
+      {},
+      null,
+      2,
+    ),
+  );
+  const cmd = new Deno.Command(Deno.execPath(), {
+    args: ["add", "jsr:@inspatial/cloud"],
+    stdout: "piped",
+    stderr: "piped",
+  });
+
+  const proc = cmd.spawn();
+
+  proc.stdout.pipeTo(
+    new WritableStream({
+      write(chunk) {
+        console.log(center(new TextDecoder().decode(chunk)));
+      },
+    }),
+  );
+  proc.stderr.pipeTo(
+    new WritableStream({
+      write(chunk) {
+        console.log(center(new TextDecoder().decode(chunk)));
+      },
+    }),
+  );
+  proc.status.then((status) => {
+    Deno.writeTextFileSync("main.ts", makeMainFile(projectName));
+    if (status.success) {
+      inLog.info([
+        `Project ${name} initialized successfully!`,
+        "",
+        "You can now run your project:",
+        `cd ${folderName}`,
+        `incloud run main.ts`,
+      ]);
+    } else {
+      inLog.error(`Failed to initialize project ${name}.`);
+      Deno.exit(1);
+    }
+  }).catch((err) => {
+    inLog.error(`Error initializing project: ${err.message}`);
+    Deno.exit(1);
+  });
+}
+
+function init() {
+  inLog.setConfig({
+    logTrace: false,
+  });
+  const rootPath = Deno.cwd();
+  const { command, file } = parseArgs();
+  switch (command) {
+    case "run":
+      doRun(rootPath, file);
+      break;
+    case "init":
+      doInit(rootPath, file);
+      break;
+
+    default:
+      console.error(`Unknown command: ${command}`);
+      Deno.exit(1);
+  }
+}
+
+init();

cli/src/cloud-config.ts

@@ -0,0 +1,39 @@
+import { joinPath } from "~/utils/path-utils.ts";
+import convertString from "~/utils/convert-string.ts";
+import type { BuiltInConfig } from "./config-types.ts";
+
+/**
+ * Checks for a cloud-config.json file in the current working directory and loads it to the environment variables.
+ */
+export function loadCloudConfigFile(
+  cloudRoot: string,
+): { config: BuiltInConfig; env: Record<string, any> } | false {
+  const builtInConfig: Record<string, Record<string, any>> = {};
+  const env: Record<string, any> = {};
+  try {
+    const filePath = joinPath(cloudRoot, "cloud-config.json");
+    const file = Deno.readTextFileSync(filePath);
+    const config = JSON.parse(file);
+    for (const key in config) {
+      if (key.startsWith("$")) {
+        continue;
+      }
+      const extensionConfig = config[key];
+      for (const subKey in extensionConfig) {
+        if (!Object.keys(builtInConfig).includes(key)) {
+          builtInConfig[key] = {};
+        }
+        builtInConfig[key][convertString(subKey, "camel")] =
+          extensionConfig[subKey];
+        env[subKey] = extensionConfig[subKey].toString();
+      }
+    }
+    // TODO: Validate the config against the schema
+    return { config: builtInConfig as unknown as BuiltInConfig, env };
+  } catch (e) {
+    if (e instanceof Deno.errors.NotFound) {
+      return false;
+    }
+    throw e;
+  }
+}

cli/src/config-types.ts

@@ -0,0 +1,45 @@
+export type ORMConfig = {
+  autoTypes: boolean;
+  autoMigrate: boolean;
+  embeddedDb: boolean;
+  embeddedDbPort: number;
+  ormDebugMode: boolean;
+  dbConnectionType: "tcp" | "socket";
+  dbSocketPath: string;
+  dbName: string;
+  dbHost: string;
+  dbPort: number;
+  dbUser: string;
+  dbPassword: string;
+  dbSchema: string;
+  dbAppName: string;
+  dbClientMode: "pool" | "single";
+  dbPoolSize: number;
+  dbMaxPoolSize: number;
+  dbIdleTimeout: number;
+};
+export type AuthConfig = {
+  allowAll: boolean;
+};
+
+export type CloudConfig = {
+  name: string;
+  cloudMode: "production" | "development";
+  logLevel: "info" | "debug" | "error" | "warn";
+  logTrace: boolean;
+  brokerPort: number;
+  queuePort: number;
+  hostName: string;
+  port: number;
+  autoConfig: boolean;
+  allowedOrigins: Set<string>;
+  publicRoot: string;
+  singlePageApp: boolean;
+  cacheStatic: boolean;
+};
+
+export interface BuiltInConfig {
+  cloud: CloudConfig;
+  orm: ORMConfig;
+  auth: AuthConfig;
+}