@liquidmetal-ai/raindrop 0.13.0 → 0.15.0

package/bundle/chunk-KVAWPWF7.js

@@ -1,231 +0,0 @@
-import {
-  FileSystemBundle,
-  archive
-} from "./chunk-25T7MEKO.js";
-import {
-  buildHandlers
-} from "./chunk-O3QZDJ75.js";
-import {
-  tmpdir
-} from "./chunk-IMP7O5AC.js";
-import {
-  BundleArchiveType,
-  Code,
-  ConnectError,
-  ReleaseRequest_LockSchema,
-  create,
-  init_cjs_shims,
-  listEnvVars,
-  valueOf
-} from "./chunk-FTPZ6SQW.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
-};