@liquidmetal-ai/raindrop 0.7.0 → 0.8.0

package/bundle/chunk-XYJACVNA.js

@@ -0,0 +1,231 @@
+import {
+  FileSystemBundle,
+  archive
+} from "./chunk-MGM2L2T3.js";
+import {
+  buildHandlers
+} from "./chunk-VXAZKB3J.js";
+import {
+  tmpdir
+} from "./chunk-PU4RCSXF.js";
+import {
+  BundleArchiveType,
+  Code,
+  ConnectError,
+  ReleaseRequest_LockSchema,
+  create,
+  init_cjs_shims,
+  listEnvVars,
+  valueOf
+} from "./chunk-G6NE675D.js";
+
+// src/deploy.ts
+init_cjs_shims();
+import fs from "node:fs/promises";
+import * as path from "node:path";
+async function deploy(options) {
+  const { command, root, manifest, output } = options;
+  const manifestPath = path.isAbsolute(manifest) ? manifest : path.join(root, manifest);
+  const buildDir = path.isAbsolute(output) ? output : path.join(root, output);
+  const apps = await command.loadManifest();
+  if (apps[0] === void 0) {
+    command.error("There are no applications in the manifest");
+    return "";
+  }
+  const app = apps[0];
+  const manifestContents = await fs.readFile(manifestPath, "utf8");
+  await buildHandlers(command, apps, buildDir, root);
+  const runtimeVersion = await command.raindropFrameworkVersion();
+  const { client: catalogService, userId, organizationId: defaultOrganizationId } = await command.catalogService();
+  const organizationId = options.impersonate ?? defaultOrganizationId;
+  let deployResp;
+  try {
+    deployResp = await catalogService.deploy({
+      userId,
+      organizationId,
+      applications: [
+        {
+          application: valueOf(app.name),
+          previousVersionId: options.previousVersionId,
+          currentVersionId: options.currentVersionId,
+          branch: options.branch,
+          amend: options.amend,
+          metadata: {
+            runtimeVersion
+          },
+          manifest: manifestContents,
+          lock: options.lock,
+          suite: ""
+        }
+      ]
+    });
+  } catch (err) {
+    if (err instanceof ConnectError && err.code === Code.FailedPrecondition) {
+      command.error(
+        `Failed to ${options.amend ? "amend" : "deploy"} ${valueOf(app.name)}@${options.previousVersionId}=>${options.currentVersionId}: ${err.message}`
+      );
+    }
+    throw err;
+  }
+  if (deployResp.applications[0] === void 0) {
+    command.error("Failed to deploy application");
+  }
+  const currentVersionId = deployResp.applications[0].currentVersionId;
+  if (!currentVersionId) {
+    command.error("Failed to retrieve current version ID from deployment response.");
+  }
+  const lock = deployResp.applications[0].lock;
+  const config = await command.loadConfig();
+  config.versionId = currentVersionId;
+  config.lock = lock;
+  await command.saveConfig(config);
+  await checkEnvironmentVariables(command, app, catalogService, userId, organizationId, currentVersionId);
+  await uploadBundles(command, app, buildDir, catalogService, userId, organizationId, currentVersionId);
+  await uploadDbBundle(command, root, catalogService, userId, organizationId, app, currentVersionId);
+  if (options.start) {
+    await catalogService.setActive({
+      userId,
+      organizationId,
+      applications: deployResp.applications.map((a) => ({
+        applicationName: a.applicationName,
+        currentVersionId: a.currentVersionId,
+        isActive: options.start
+      }))
+    });
+  }
+  await catalogService.release({
+    userId,
+    organizationId,
+    locks: deployResp.applications.map(
+      (a) => create(ReleaseRequest_LockSchema, {
+        applicationName: a.applicationName,
+        currentVersionId: a.currentVersionId,
+        lock: a.lock
+      })
+    )
+  });
+  config.lock = void 0;
+  await command.saveConfig(config);
+  return currentVersionId;
+}
+async function checkEnvironmentVariables(command, app, catalogService, userId, organizationId, currentVersionId) {
+  const envVars = listEnvVars(app);
+  if (Object.keys(envVars).length > 0) {
+    const getEnvsResp = await catalogService.getEnvs({
+      userId,
+      organizationId,
+      envs: Object.keys(envVars).map((key) => ({
+        applicationName: valueOf(app.name),
+        currentVersionId,
+        key
+      }))
+    });
+    let unset = false;
+    const remoteEnvVars = Object.fromEntries(getEnvsResp.envs.map((env) => [env.key, env.value]));
+    for (const key of Object.keys(envVars)) {
+      const manifestDefault = envVars[key]?.default;
+      const remoteValue = remoteEnvVars[key];
+      if (remoteValue === void 0 && manifestDefault === void 0) {
+        if (!unset) {
+          command.warn(`The following environment variables were not set and are required for deployment:`);
+        }
+        unset = true;
+        command.warn(key);
+      }
+    }
+    if (unset) {
+      command.error(
+        "Please set environment variables before deploying. You can resume using `raindrop build deploy --amend`"
+      );
+    }
+  }
+}
+async function uploadBundles(command, app, buildDir, catalogService, userId, organizationId, currentVersionId) {
+  await Promise.all(
+    app.handlers().map(async (handler) => {
+      const bundle = new FileSystemBundle(path.join(buildDir, valueOf(handler.name)));
+      await catalogService.uploadBundle({
+        userId,
+        organizationId,
+        applicationName: valueOf(app.name),
+        applicationVersionId: currentVersionId,
+        archiveType: BundleArchiveType.ZIP,
+        bundleName: valueOf(handler.name),
+        archive: Buffer.from(await archive(bundle))
+      });
+      command.log(`Uploaded bundle "${valueOf(handler.name)}"`);
+    })
+  );
+}
+async function uploadDbBundle(command, root, catalogService, userId, organizationId, app, currentVersionId) {
+  const dbDir = path.join(root, "db");
+  let dbExists = false;
+  try {
+    const stat = await fs.lstat(dbDir);
+    dbExists = stat.isDirectory();
+  } catch (_e) {
+  }
+  if (dbExists) {
+    command.log(`Checking for SQL files in ${dbDir}`);
+    const files = await fs.readdir(dbDir, {
+      withFileTypes: true
+    });
+    const folders = files.filter((file) => file.isDirectory());
+    try {
+      const tempDir = tmpdir();
+      for (const folder of folders) {
+        const sqlFiles = (await fs.readdir(path.join(dbDir, folder.name))).filter((file) => file.endsWith(".sql"));
+        const tmpDbFolder = await fs.mkdir(path.join(tempDir, folder.name), { recursive: true });
+        for (const sqlFile of sqlFiles) {
+          await fs.copyFile(path.join(dbDir, folder.name, sqlFile), path.join(tmpDbFolder, sqlFile));
+        }
+      }
+      const dbBundle = new FileSystemBundle(tempDir);
+      await catalogService.uploadBundle({
+        userId,
+        organizationId,
+        applicationName: valueOf(app.name),
+        applicationVersionId: currentVersionId,
+        archiveType: BundleArchiveType.ZIP,
+        bundleName: "db",
+        archive: Buffer.from(await archive(dbBundle))
+      });
+      command.log(`Uploaded db bundle with SQL files`);
+      await fs.rm(tempDir, { recursive: true, force: true });
+    } catch (error) {
+      command.log(`Failed to upload db bundle: ${error}`);
+    }
+  }
+}
+async function sandbox(options) {
+  const { command, versionId: versionIdRaw, impersonate, isSandboxed } = options;
+  const config = await command.loadConfig();
+  const { client: catalogService, userId, organizationId: defaultOrganizationId } = await command.catalogService();
+  const organizationId = impersonate ?? defaultOrganizationId;
+  const apps = await command.loadManifest();
+  const app = apps[0];
+  const versionId = versionIdRaw ?? config.versionId;
+  if (!app) {
+    throw new Error("No application found");
+  }
+  const applications = [
+    {
+      applicationName: valueOf(app.name),
+      currentVersionId: versionId,
+      isSandboxed
+    }
+  ];
+  await catalogService.setSandbox({
+    userId,
+    organizationId,
+    applications
+  });
+  config.sandbox = isSandboxed;
+  await command.saveConfig(config);
+  return applications;
+}
+
+export {
+  deploy,
+  sandbox
+};

package/bundle/commands/annotation/get.js

@@ -0,0 +1,153 @@
+import {
+  parseMRN
+} from "../../chunk-AU3EGGJP.js";
+import {
+  BaseCommand
+} from "../../chunk-MCRKUPJY.js";
+import {
+  AnnotationLocatorSchema,
+  GetAnnotationRequestSchema,
+  __toESM,
+  create,
+  init_cjs_shims,
+  require_lib,
+  valueOf
+} from "../../chunk-G6NE675D.js";
+
+// src/commands/annotation/get.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var AnnotationGet = class _AnnotationGet extends BaseCommand {
+  static args = {
+    mrn: import_core.Args.string({
+      description: "MRN (Machine Resource Name) of the annotation to retrieve. Can be partial (e.g., my-module:my-key:) or full (e.g., annotation:app:v1:my-module:my-key:)",
+      required: true
+    })
+  };
+  static description = "Get an annotation by MRN";
+  static examples = [
+    `<%= config.bin %> annotation get my-module:my-item^my-key:
+Get annotation by partial MRN (prefilled with app/version from manifest and config)
+`,
+    `<%= config.bin %> annotation get annotation:my-app:v1.0.0:my-module:my-item^my-key:
+Get annotation with the full MRN
+`,
+    `<%= config.bin %> annotation get my-module:my-key: --format json
+Get annotation by partial MRN and output as JSON
+`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS,
+    format: import_core.Flags.string({
+      char: "f",
+      description: "output format",
+      default: "text",
+      options: ["text", "json"]
+    }),
+    impersonate: import_core.Flags.string({
+      char: "i",
+      description: "impersonate organization",
+      required: false,
+      hidden: true
+    }),
+    manifest: import_core.Flags.string({
+      char: "M",
+      description: "project manifest",
+      required: false,
+      default: "raindrop.manifest",
+      hidden: true
+    })
+  };
+  async run() {
+    const { args, flags } = await this.parse(_AnnotationGet);
+    let fullMrn = args.mrn;
+    let mrnParts;
+    if (!args.mrn.startsWith("annotation:") && !args.mrn.startsWith("label:")) {
+      const apps = await this.loadManifest();
+      const config = await this.loadConfig();
+      if (apps.length === 0) {
+        this.error("No applications found in manifest");
+      }
+      const app = apps[0];
+      const appName = valueOf(app.name);
+      const versionId = config.versionId;
+      console.log(`Using application: ${appName}, version: ${versionId}`);
+      if (!appName) {
+        this.error("Application name not found in manifest");
+      }
+      if (!versionId) {
+        this.error("Version ID not found in config. Run a build or deployment first to set the version.");
+      }
+      fullMrn = `annotation:${appName}:${versionId}:${args.mrn}`;
+    }
+    const parts = fullMrn.split(":");
+    if (parts.length < 6) {
+      const colonsToAdd = 6 - parts.length;
+      fullMrn += ":".repeat(colonsToAdd);
+    }
+    try {
+      mrnParts = parseMRN(fullMrn);
+    } catch (error) {
+      this.error(`Invalid MRN format: ${error}`);
+    }
+    const {
+      client: annotationServiceClient,
+      userId,
+      organizationId
+    } = await this.annotationService();
+    try {
+      const locator = create(AnnotationLocatorSchema, {
+        applicationName: mrnParts.applicationName,
+        applicationVersionId: mrnParts.versionId,
+        moduleName: mrnParts.module,
+        item: mrnParts.item,
+        key: mrnParts.key,
+        revision: mrnParts.revision
+      });
+      const request = create(GetAnnotationRequestSchema, {
+        userId,
+        organizationId,
+        locator
+      });
+      const response = await annotationServiceClient.getAnnotation(request);
+      switch (flags.format) {
+        case "json":
+          console.log(
+            JSON.stringify(
+              {
+                mrn: fullMrn,
+                inputMrn: args.mrn,
+                ...mrnParts,
+                annotation: response.annotation?.annotation || "",
+                location: response.annotation?.location
+              },
+              null,
+              2
+            )
+          );
+          break;
+        case "text":
+          console.log(`MRN: ${fullMrn}`);
+          if (fullMrn !== args.mrn) {
+            console.log(`Input: ${args.mrn} (prefilled with app/version)`);
+          }
+          console.log(`Type: ${mrnParts.type}`);
+          console.log(`Application: ${mrnParts.applicationName}`);
+          console.log(`Version: ${mrnParts.versionId}`);
+          if (mrnParts.module) console.log(`Module: ${mrnParts.module}`);
+          if (mrnParts.item) console.log(`Item: ${mrnParts.item}`);
+          if (mrnParts.key) console.log(`Key: ${mrnParts.key}`);
+          if (mrnParts.revision) console.log(`Revision: ${mrnParts.revision}`);
+          console.log("");
+          console.log("Annotation:");
+          console.log(response.annotation?.annotation || "(no content)");
+          break;
+      }
+    } catch (error) {
+      this.error(`Failed to get annotation: ${error}`);
+    }
+  }
+};
+export {
+  AnnotationGet as default
+};

package/bundle/commands/annotation/list.js

@@ -0,0 +1,226 @@
+import {
+  parseMRN
+} from "../../chunk-AU3EGGJP.js";
+import {
+  BaseCommand
+} from "../../chunk-MCRKUPJY.js";
+import {
+  AnnotationLocatorSchema,
+  ListAnnotationsRequestSchema,
+  __toESM,
+  create,
+  init_cjs_shims,
+  require_lib,
+  valueOf
+} from "../../chunk-G6NE675D.js";
+
+// src/commands/annotation/list.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var AnnotationList = class _AnnotationList extends BaseCommand {
+  static args = {
+    mrnPrefix: import_core.Args.string({
+      description: "MRN prefix to filter annotations (e.g., my-module or annotation:app:v1:my-module). If not provided, uses app/version from manifest and config.",
+      required: false
+    })
+  };
+  static description = "List annotations by MRN prefix";
+  static examples = [
+    `<%= config.bin %> annotation list
+List all annotations for the current app/version from manifest and config
+`,
+    `<%= config.bin %> annotation list my-module
+List annotations for 'my-module' (prefilled with app/version from manifest and config)
+`,
+    `<%= config.bin %> annotation list annotation:my-app:v1.0.0:my-module --format json
+List annotations for a specific module using full MRN prefix in JSON format
+`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS,
+    output: import_core.Flags.string({
+      char: "o",
+      description: "output format",
+      default: "table",
+      options: ["table", "text", "json"]
+    }),
+    limit: import_core.Flags.integer({
+      char: "l",
+      description: "maximum number of annotations to return",
+      default: 100
+    }),
+    impersonate: import_core.Flags.string({
+      char: "i",
+      description: "impersonate organization",
+      required: false,
+      hidden: true
+    }),
+    manifest: import_core.Flags.string({
+      char: "M",
+      description: "project manifest",
+      required: false,
+      default: "raindrop.manifest",
+      hidden: true
+    })
+  };
+  async run() {
+    const { args, flags } = await this.parse(_AnnotationList);
+    let mrnParts = {};
+    let fullMrnPrefix = args.mrnPrefix || "";
+    if (args.mrnPrefix) {
+      if (!args.mrnPrefix.startsWith("annotation:") && !args.mrnPrefix.startsWith("label:")) {
+        const apps = await this.loadManifest();
+        const config = await this.loadConfig();
+        if (apps.length === 0) {
+          this.error("No applications found in manifest");
+        }
+        const app = apps[0];
+        const manifestAppName = valueOf(app.name);
+        const configVersionId = config.versionId;
+        if (!manifestAppName) {
+          this.error("Application name not found in manifest");
+        }
+        if (!configVersionId) {
+          this.error("Version ID not found in config. Run a build or deployment first to set the version.");
+        }
+        fullMrnPrefix = `annotation:${manifestAppName}:${configVersionId}:${args.mrnPrefix}`;
+      }
+      try {
+        mrnParts = parseMRN(fullMrnPrefix);
+      } catch {
+        const parts = fullMrnPrefix.split(":");
+        if (parts.length >= 3 && parts[0] === "annotation") {
+          mrnParts = {
+            type: parts[0],
+            applicationName: parts[1],
+            versionId: parts[2],
+            module: parts[3] || void 0,
+            key: parts[4] || void 0,
+            revision: parts[5] || void 0
+          };
+        } else {
+          this.error("MRN prefix must at least contain annotation:applicationName:versionId");
+        }
+      }
+    } else {
+      const apps = await this.loadManifest();
+      const config = await this.loadConfig();
+      if (apps.length === 0) {
+        this.error("No applications found in manifest");
+      }
+      const app = apps[0];
+      const manifestAppName = valueOf(app.name);
+      const configVersionId = config.versionId;
+      if (!manifestAppName) {
+        this.error("Application name not found in manifest");
+      }
+      if (!configVersionId) {
+        this.error("Version ID not found in config. Run a build or deployment first to set the version.");
+      }
+      fullMrnPrefix = `annotation:${manifestAppName}:${configVersionId}`;
+      mrnParts = {
+        type: "annotation",
+        applicationName: manifestAppName,
+        versionId: configVersionId
+      };
+    }
+    const {
+      client: annotationServiceClient,
+      userId,
+      organizationId
+    } = await this.annotationService();
+    try {
+      const locator = create(AnnotationLocatorSchema, {
+        applicationName: mrnParts.applicationName,
+        applicationVersionId: mrnParts.versionId,
+        moduleName: mrnParts.module,
+        item: mrnParts.item,
+        key: mrnParts.key,
+        revision: mrnParts.revision
+      });
+      const request = create(ListAnnotationsRequestSchema, {
+        userId,
+        organizationId,
+        locator
+      });
+      const response = await annotationServiceClient.listAnnotations(request);
+      const annotations = response.annotation || [];
+      switch (flags.output) {
+        case "json":
+          console.log(
+            JSON.stringify(
+              {
+                annotations: annotations.map((loc) => ({
+                  applicationName: loc.applicationName,
+                  applicationVersionId: loc.applicationVersionId,
+                  moduleName: loc.moduleName,
+                  item: loc.item,
+                  key: loc.key,
+                  revision: loc.revision
+                })),
+                total: annotations.length,
+                prefix: fullMrnPrefix,
+                inputPrefix: args.mrnPrefix
+              },
+              null,
+              2
+            )
+          );
+          break;
+        case "text":
+          console.log(`Found ${annotations.length} annotations`);
+          console.log(`Prefix: ${fullMrnPrefix}`);
+          if (fullMrnPrefix !== (args.mrnPrefix || "")) {
+            console.log(`Input: ${args.mrnPrefix || "(none)"} (prefilled with app/version)`);
+          }
+          console.log("");
+          annotations.forEach((loc, index) => {
+            const mrn = `${loc.applicationName}:${loc.applicationVersionId}:${loc.moduleName || ""}:${loc.item || ""}^${loc.key || ""}:${loc.revision || ""}`;
+            console.log(`${index + 1}. ${mrn}`);
+            console.log(`   Application: ${loc.applicationName}`);
+            console.log(`   Version: ${loc.applicationVersionId}`);
+            if (loc.moduleName) console.log(`   Module: ${loc.moduleName}`);
+            if (loc.item) console.log(`   Item: ${loc.item}`);
+            if (loc.key) console.log(`   Key: ${loc.key}`);
+            if (loc.revision) console.log(`   Revision: ${loc.revision}`);
+            console.log("");
+          });
+          break;
+        case "table":
+          if (annotations.length === 0) {
+            console.log("No annotations found");
+            console.log(`Prefix: ${fullMrnPrefix}`);
+            if (fullMrnPrefix !== (args.mrnPrefix || "")) {
+              console.log(`Input: ${args.mrnPrefix || "(none)"} (prefilled with app/version)`);
+            }
+          } else {
+            console.log("Application     Version         Module          Item            Key             Revision");
+            console.log(
+              "--------------- --------------- --------------- --------------- --------------- ---------------"
+            );
+            annotations.forEach((loc) => {
+              const app = (loc.applicationName || "").padEnd(15).substring(0, 15);
+              const version = (loc.applicationVersionId || "").padEnd(15).substring(0, 15);
+              const module = (loc.moduleName || "").padEnd(15).substring(0, 15);
+              const item = (loc.item || "").padEnd(15).substring(0, 15);
+              const key = (loc.key || "").padEnd(15).substring(0, 15);
+              const revision = (loc.revision || "").padEnd(15).substring(0, 15);
+              console.log(`${app} ${version} ${module} ${item} ${key} ${revision}`);
+            });
+            console.log(`
+Total: ${annotations.length} annotations`);
+            console.log(`Prefix: ${fullMrnPrefix}`);
+            if (fullMrnPrefix !== (args.mrnPrefix || "")) {
+              console.log(`Input: ${args.mrnPrefix || "(none)"} (prefilled with app/version)`);
+            }
+          }
+          break;
+      }
+    } catch (error) {
+      this.error(`Failed to list annotations: ${error}`);
+    }
+  }
+};
+export {
+  AnnotationList as default
+};