@liquidmetal-ai/raindrop 0.13.0 → 0.15.0

package/bundle/chunk-WFZUJLEC.js

@@ -1,231 +0,0 @@
-import {
-  FileSystemBundle,
-  archive
-} from "./chunk-7ZJWA6HP.js";
-import {
-  buildHandlers
-} from "./chunk-XKKPPSPC.js";
-import {
-  tmpdir
-} from "./chunk-MEUAAIXV.js";
-import {
-  BundleArchiveType,
-  Code,
-  ConnectError,
-  ReleaseRequest_LockSchema,
-  create,
-  init_cjs_shims,
-  listEnvVars,
-  valueOf
-} from "./chunk-PS3WZBDF.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/chunk-YDGJTLVZ.js

@@ -1,133 +0,0 @@
-import {
-  init_cjs_shims,
-  timestampMs
-} from "./chunk-PS3WZBDF.js";
-
-// src/log-helpers.ts
-init_cjs_shims();
-function formatLogAttribute(key, value, displayValue) {
-  if (key === "http.status") {
-    const statusCode = parseInt(value);
-    const statusEmoji = statusCode >= 200 && statusCode < 300 ? "\u2705" : statusCode >= 400 ? "\u274C" : "\u26A0\uFE0F";
-    return `${key}: ${statusEmoji} ${value}`;
-  } else if (key === "http.method" || key === "http.url") {
-    return `${key}: ${value}`;
-  } else if (key === "query") {
-    return `\u{1F5C4}\uFE0F  SQL Query: ${value}`;
-  } else if (key === "rows_read") {
-    return `\u{1F4CA} Rows Read: ${value}`;
-  } else if (key === "rows_written") {
-    return `\u270D\uFE0F  Rows Written: ${value}`;
-  } else if (key === "db") {
-    return `\u{1F3E6} Database: ${value}`;
-  } else if (key === "error") {
-    if (value && value !== "undefined") {
-      return `\u274C Error: ${value}`;
-    }
-    return null;
-  } else if (key === "fields" || key === "meta") {
-    try {
-      const parsed = JSON.parse(displayValue);
-      if (key === "meta" && parsed) {
-        const metrics = [];
-        if (parsed.duration) metrics.push(`${parsed.duration}ms`);
-        if (parsed.rows_read) metrics.push(`${parsed.rows_read} rows read`);
-        if (parsed.rows_written && parsed.rows_written > 0) metrics.push(`${parsed.rows_written} rows written`);
-        if (parsed.served_by_region) metrics.push(`${parsed.served_by_region}`);
-        if (parsed.size_after) metrics.push(`DB: ${(parsed.size_after / 1024).toFixed(1)}KB`);
-        if (metrics.length > 0) {
-          return `\u{1F4CA} ${key}: ${metrics.join(", ")}`;
-        } else {
-          return `${key}: ${JSON.stringify(parsed, (_, v) => typeof v === "bigint" ? v.toString() : v)}`;
-        }
-      } else {
-        return `${key}: ${JSON.stringify(parsed, (_, v) => typeof v === "bigint" ? v.toString() : v)}`;
-      }
-    } catch {
-      return `${key}: ${displayValue}`;
-    }
-  } else {
-    return `${key}: ${displayValue}`;
-  }
-}
-function displayEventAttributes(event, logger, indentLevel = "     ") {
-  if (event.attributes && Object.keys(event.attributes).length > 0) {
-    Object.entries(event.attributes).forEach(([key, value]) => {
-      if (value !== void 0 && value !== null) {
-        let displayValue = value;
-        try {
-          const parsed = JSON.parse(value);
-          if (typeof parsed === "object" && parsed !== null) {
-            displayValue = JSON.stringify(parsed, (_, v) => {
-              if (typeof v === "bigint") {
-                return v.toString();
-              }
-              return v;
-            }, 2);
-          }
-        } catch {
-        }
-        const formattedAttribute = formatLogAttribute(key, value, displayValue);
-        if (formattedAttribute) {
-          logger.log(`${indentLevel}${formattedAttribute}`);
-        }
-      }
-    });
-  }
-}
-function displayTraceGroupedEvents(events, logger) {
-  const eventsByTrace = /* @__PURE__ */ new Map();
-  events.forEach((event) => {
-    const traceId = event.trace?.eventId || "unknown";
-    if (!eventsByTrace.has(traceId)) {
-      eventsByTrace.set(traceId, []);
-    }
-    const traceEvents = eventsByTrace.get(traceId);
-    if (traceEvents) {
-      traceEvents.push(event);
-    }
-  });
-  for (const [traceId, traceEvents] of eventsByTrace) {
-    if (traceEvents.length === 0) continue;
-    traceEvents.sort((a, b) => {
-      if (a.eventOrder !== void 0 && b.eventOrder !== void 0) {
-        return a.eventOrder - b.eventOrder;
-      }
-      const aTime = a.trace?.startTime ? timestampMs(a.trace.startTime) : 0;
-      const bTime = b.trace?.startTime ? timestampMs(b.trace.startTime) : 0;
-      return aTime - bTime;
-    });
-    const firstEvent = traceEvents[0];
-    const lastEvent = traceEvents[traceEvents.length - 1];
-    const startTime = firstEvent.trace?.startTime ? timestampMs(firstEvent.trace.startTime) : 0;
-    const endTime = lastEvent.trace?.endTime ? timestampMs(lastEvent.trace.endTime) : lastEvent.trace?.startTime ? timestampMs(lastEvent.trace.startTime) : 0;
-    const traceDuration = endTime > startTime ? ` (${endTime - startTime}ms total)` : "";
-    const timestamp = firstEvent.trace?.startTime ? new Date(timestampMs(firstEvent.trace.startTime)).toLocaleString() : "Unknown time";
-    logger.log(`[${timestamp}] \u{1F517} Trace: ${traceId}${traceDuration}`);
-    if (firstEvent.organization?.id || firstEvent.application?.name) {
-      const contextParts = [];
-      if (firstEvent.organization?.id) contextParts.push(`Org: ${firstEvent.organization.id}`);
-      if (firstEvent.application?.name) contextParts.push(`App: ${firstEvent.application.name}`);
-      if (firstEvent.application?.version?.id) contextParts.push(`v${firstEvent.application.version.id}`);
-      if (firstEvent.script?.name) contextParts.push(`Script: ${firstEvent.script.name}`);
-      logger.log(`  ${contextParts.join(", ")}`);
-    }
-    traceEvents.forEach((event, index) => {
-      const eventName = event.name || "Event";
-      const status = event.status || "ok";
-      const statusEmoji = status === "error" ? "\u274C" : "\u2705";
-      let duration = "";
-      if (event.trace?.endTime && event.trace?.startTime) {
-        const durationMs = timestampMs(event.trace.endTime) - timestampMs(event.trace.startTime);
-        duration = ` (${durationMs}ms)`;
-      }
-      logger.log(`  ${index + 1}. ${statusEmoji} ${eventName}${duration}`);
-      displayEventAttributes(event, logger, "     ");
-    });
-    logger.log("");
-  }
-}
-
-export {
-  displayTraceGroupedEvents
-};