@superblocksteam/sdk 2.0.102-next.0 → 2.0.102

package/src/collect-sdk-apis.mts

@@ -1,5 +1,4 @@
 import path from "node:path";
-
 import {
   extractIntegrationsFromSource,
   type IntegrationInfo,

package/src/collect-sdk-apis.test.mts

@@ -1,7 +1,5 @@
 import path from "node:path";
-
 import { describe, it, expect, vi } from "vitest";
-
 import { collectSdkApisFromRegistry } from "./collect-sdk-apis.mjs";
 
 describe("collectSdkApisFromRegistry", () => {

package/src/dbfs/client.test.ts

@@ -1,6 +1,5 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
 import { ExportViewMode, NotFoundError } from "@superblocksteam/shared";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 
 const { connectToISocketRPCServer, unwrapResponseDto, warn } = vi.hoisted(
   () => ({

package/src/dbfs/client.ts

@@ -4,7 +4,6 @@ import {
   NotFoundError,
 } from "@superblocksteam/shared";
 import { unreachable } from "@superblocksteam/util";
-
 import { connectToISocketRPCServer } from "../socket/index.js";
 import { getLogger } from "../telemetry/logging.js";
 import { doDownloadDirectoryToLocal, doUploadLocalDirectory } from "./local.js";

package/src/dbfs/local.ts

@@ -1,5 +1,4 @@
 import * as fsp from "node:fs/promises";
-
 import {
   hashDirectoryContents,
   hashFileContents,
@@ -7,7 +6,6 @@ import {
 } from "@superblocksteam/shared";
 import { unreachable } from "@superblocksteam/util";
 import { listLocalDirectory } from "@superblocksteam/vite-plugin-file-sync/list-dir";
-
 import type { StdISocketRPCClient } from "../socket/index.js";
 
 export async function doDownloadDirectoryToLocal(

package/src/dev-utils/custom-build.mts

@@ -1,13 +1,11 @@
 import path from "node:path";
-
 import watcher, { type FSWatcher } from "chokidar";
 import { red } from "colorette";
 import fs from "fs-extra";
 import semver from "semver";
 import { build } from "vite";
-import type { Plugin, UserConfig, ViteDevServer } from "vite";
-
 import { getLegacyComponentsConfig } from "./custom-config.mjs";
+import type { Plugin, UserConfig, ViteDevServer } from "vite";
 
 // we only need to build if not on React 18
 export async function isCustomComponentsEnabled() {

package/src/dev-utils/custom-config.mts

@@ -1,5 +1,4 @@
 import path from "node:path";
-
 import react from "@vitejs/plugin-react";
 import glob from "fast-glob";
 import { defineConfig } from "vite";

package/src/dev-utils/dev-server.mts

@@ -1,17 +1,6 @@
-import type http from "node:http";
 import net from "node:net";
 import os from "node:os";
 import path from "node:path";
-
-import react from "@vitejs/plugin-react";
-import cors from "cors";
-import express from "express";
-import type { IRouter, RequestHandler } from "express";
-import { createLogger, createServer, loadEnv } from "vite";
-import type { HmrOptions } from "vite";
-import type { ViteDevServer } from "vite";
-import tsconfigPaths from "vite-tsconfig-paths";
-
 import {
   JwtVerifier,
   SUPERBLOCKS_LIVE_GIT_BRANCH,
@@ -22,17 +11,12 @@ import {
   type FileSyncPluginParams,
   fileSyncVitePlugin,
 } from "@superblocksteam/vite-plugin-file-sync";
-import type {
-  AiService,
-  SnapshotManager,
-} from "@superblocksteam/vite-plugin-file-sync/ai-service";
-import type { GitService } from "@superblocksteam/vite-plugin-file-sync/git-service";
-import type { LockService } from "@superblocksteam/vite-plugin-file-sync/lock-service";
-import type { OperationQueue } from "@superblocksteam/vite-plugin-file-sync/operation-queue";
-import type { SyncService } from "@superblocksteam/vite-plugin-file-sync/sync-service";
-
+import react from "@vitejs/plugin-react";
+import cors from "cors";
+import express from "express";
+import { createLogger, createServer, loadEnv } from "vite";
+import tsconfigPaths from "vite-tsconfig-paths";
 import pkg from "../../package.json" with { type: "json" };
-import type { SuperblocksSdk } from "../sdk.js";
 import { getTracer } from "../telemetry/index.js";
 import { getErrorMeta, getLogger } from "../telemetry/logging.js";
 import {
@@ -40,6 +24,7 @@ import {
   type SuperblocksScopedJwtPayload,
 } from "../types/scoped-jwt-token-payload.js";
 import { getCurrentGitBranchIfGit } from "../version-control.mjs";
+
 import createLucideReactImportOptimizer from "../vite-plugin-optimize-lucide-imports.js";
 import { sdkApiEntryPointPlugin } from "../vite-plugin-sdk-api-entry-point.mjs";
 import {
@@ -48,6 +33,19 @@ import {
 } from "./custom-build.mjs";
 import { buildManifestStubPlugin } from "./vite-plugin-build-manifest-stub.mjs";
 import { ddRumPlugin } from "./vite-plugin-dd-rum.mjs";
+import type { SuperblocksSdk } from "../sdk.js";
+import type {
+  AiService,
+  SnapshotManager,
+} from "@superblocksteam/vite-plugin-file-sync/ai-service";
+import type { GitService } from "@superblocksteam/vite-plugin-file-sync/git-service";
+import type { LockService } from "@superblocksteam/vite-plugin-file-sync/lock-service";
+import type { OperationQueue } from "@superblocksteam/vite-plugin-file-sync/operation-queue";
+import type { SyncService } from "@superblocksteam/vite-plugin-file-sync/sync-service";
+import type { IRouter, RequestHandler } from "express";
+import type http from "node:http";
+import type { HmrOptions } from "vite";
+import type { ViteDevServer } from "vite";
 
 const tracer = getTracer();
 
@@ -637,7 +635,6 @@ async function startVite({
           tracer,
           logger,
           superblocksBaseUrl,
-          appRootDir: root,
           features,
         },
         { isCustomBuildEnabled },
@@ -653,6 +650,13 @@ async function startVite({
               mode,
               clearScreen: process.env.SUPERBLOCKS_CLI_ENV !== "local",
               customLogger: viteLogger,
+              optimizeDeps: {
+                esbuildOptions: {
+                  supported: {
+                    destructuring: true,
+                  },
+                },
+              },
               server: {
                 middlewareMode: true,
                 watch: {

package/src/dev-utils/token-manager.ts

@@ -1,5 +1,4 @@
 import { EventEmitter } from "node:events";
-
 import type { ITokenManager, TokenUpdateEvent } from "@superblocksteam/util";
 
 export class TokenManager extends EventEmitter implements ITokenManager {

package/src/extract-api-integrations.mts

@@ -1,5 +1,345 @@
-export {
-  extractIntegrationIdsFromSource,
-  extractIntegrationsFromSource,
-  type IntegrationInfo,
-} from "@superblocksteam/vite-plugin-file-sync/extract-api-integrations";
+import { parse } from "@babel/parser";
+
+export type IntegrationInfo = {
+  key: string;
+  pluginId: string;
+  id: string;
+};
+
+type AstNode = {
+  type?: string;
+  [key: string]: unknown;
+};
+
+function isNode(value: unknown): value is AstNode {
+  return !!value && typeof value === "object";
+}
+
+function getPropertyName(node: unknown): string | undefined {
+  if (!isNode(node)) {
+    return undefined;
+  }
+
+  if (node.type === "Identifier" && typeof node.name === "string") {
+    return node.name;
+  }
+
+  if (node.type === "StringLiteral" && typeof node.value === "string") {
+    return node.value;
+  }
+
+  return undefined;
+}
+
+function getLiteralString(node: unknown): string | undefined {
+  if (!isNode(node)) {
+    return undefined;
+  }
+
+  if (node.type === "StringLiteral" && typeof node.value === "string") {
+    return node.value;
+  }
+
+  if (
+    node.type === "TemplateLiteral" &&
+    Array.isArray(node.expressions) &&
+    node.expressions.length === 0 &&
+    Array.isArray(node.quasis) &&
+    node.quasis.length === 1
+  ) {
+    const quasi = node.quasis[0];
+    if (
+      isNode(quasi) &&
+      isNode(quasi.value) &&
+      typeof quasi.value.cooked === "string"
+    ) {
+      return quasi.value.cooked;
+    }
+  }
+
+  return undefined;
+}
+
+function getCalleeName(node: unknown): string | undefined {
+  if (!isNode(node)) {
+    return undefined;
+  }
+
+  if (node.type === "Identifier" && typeof node.name === "string") {
+    return node.name;
+  }
+
+  if (node.type === "MemberExpression") {
+    return getPropertyName(node.property);
+  }
+
+  return undefined;
+}
+
+function unwrapExpression(node: unknown): AstNode | undefined {
+  if (!isNode(node)) {
+    return undefined;
+  }
+
+  if (
+    node.type === "TSAsExpression" ||
+    node.type === "TSTypeAssertion" ||
+    node.type === "ParenthesizedExpression"
+  ) {
+    return unwrapExpression(node.expression);
+  }
+
+  return node;
+}
+
+function buildVariableInitializerMap(
+  programBody: unknown[],
+): Map<string, unknown> {
+  const initializers = new Map<string, unknown>();
+
+  for (const statement of programBody) {
+    if (
+      !isNode(statement) ||
+      statement.type !== "VariableDeclaration" ||
+      !Array.isArray(statement.declarations)
+    ) {
+      continue;
+    }
+
+    for (const declaration of statement.declarations) {
+      if (!isNode(declaration)) {
+        continue;
+      }
+
+      const identifier = declaration.id;
+      if (
+        !isNode(identifier) ||
+        identifier.type !== "Identifier" ||
+        typeof identifier.name !== "string"
+      ) {
+        continue;
+      }
+
+      initializers.set(identifier.name, declaration.init);
+    }
+  }
+
+  return initializers;
+}
+
+function resolveApiConfigObject(
+  expression: unknown,
+  variableInitializers: Map<string, unknown>,
+): AstNode | undefined {
+  const resolvedExpression = unwrapExpression(expression);
+  if (!resolvedExpression) {
+    return undefined;
+  }
+
+  if (
+    resolvedExpression.type === "Identifier" &&
+    typeof resolvedExpression.name === "string"
+  ) {
+    return resolveApiConfigObject(
+      variableInitializers.get(resolvedExpression.name),
+      variableInitializers,
+    );
+  }
+
+  if (
+    resolvedExpression.type !== "CallExpression" ||
+    getCalleeName(resolvedExpression.callee) !== "api" ||
+    !Array.isArray(resolvedExpression.arguments)
+  ) {
+    return undefined;
+  }
+
+  const config = unwrapExpression(resolvedExpression.arguments[0]);
+  if (!config || config.type !== "ObjectExpression") {
+    return undefined;
+  }
+
+  return config;
+}
+
+function findExportedApiConfigObject(
+  programBody: unknown[],
+): AstNode | undefined {
+  const variableInitializers = buildVariableInitializerMap(programBody);
+
+  for (const statement of programBody) {
+    if (!isNode(statement)) {
+      continue;
+    }
+
+    if (statement.type === "ExportDefaultDeclaration") {
+      return resolveApiConfigObject(
+        statement.declaration,
+        variableInitializers,
+      );
+    }
+
+    if (
+      statement.type === "ExportNamedDeclaration" &&
+      Array.isArray(statement.specifiers)
+    ) {
+      for (const specifier of statement.specifiers) {
+        if (
+          !isNode(specifier) ||
+          specifier.type !== "ExportSpecifier" ||
+          getPropertyName(specifier.exported) !== "default"
+        ) {
+          continue;
+        }
+
+        return resolveApiConfigObject(specifier.local, variableInitializers);
+      }
+    }
+  }
+
+  return undefined;
+}
+
+function buildVariableReferenceMap(
+  programBody: unknown[],
+): Map<string, Omit<IntegrationInfo, "key">> {
+  const refs = new Map<string, Omit<IntegrationInfo, "key">>();
+
+  for (const statement of programBody) {
+    if (
+      !isNode(statement) ||
+      statement.type !== "VariableDeclaration" ||
+      !Array.isArray(statement.declarations)
+    ) {
+      continue;
+    }
+
+    for (const declaration of statement.declarations) {
+      if (!isNode(declaration)) {
+        continue;
+      }
+
+      const identifier = declaration.id;
+      const init = declaration.init;
+      if (
+        !isNode(identifier) ||
+        identifier.type !== "Identifier" ||
+        typeof identifier.name !== "string"
+      ) {
+        continue;
+      }
+
+      if (
+        !isNode(init) ||
+        init.type !== "CallExpression" ||
+        !Array.isArray(init.arguments)
+      ) {
+        continue;
+      }
+
+      const pluginId = getCalleeName(init.callee);
+      const id = getLiteralString(init.arguments[0]);
+      if (!pluginId || !id) {
+        continue;
+      }
+
+      refs.set(identifier.name, { pluginId, id });
+    }
+  }
+
+  return refs;
+}
+
+/**
+ * Extract integration declarations from an SDK API source file.
+ *
+ * Supports both inline declarations:
+ * `integrations: { db: postgres("uuid") }`
+ *
+ * and top-level variable references:
+ * `const DB = postgres("uuid"); integrations: { db: DB }`
+ */
+export function extractIntegrationsFromSource(
+  source: string,
+): IntegrationInfo[] {
+  let ast: ReturnType<typeof parse>;
+  try {
+    ast = parse(source, {
+      sourceType: "module",
+      plugins: ["typescript"],
+    });
+  } catch {
+    return [];
+  }
+
+  const variableRefs = buildVariableReferenceMap(ast.program.body);
+  const apiConfig = findExportedApiConfigObject(ast.program.body);
+  if (!apiConfig) {
+    return [];
+  }
+  const results: IntegrationInfo[] = [];
+
+  const apiConfigProperties = Array.isArray(apiConfig.properties)
+    ? apiConfig.properties
+    : [];
+  const integrationsProperty = apiConfigProperties.find(
+    (property: AstNode) =>
+      isNode(property) &&
+      property.type === "ObjectProperty" &&
+      getPropertyName(property.key) === "integrations",
+  );
+
+  if (
+    !isNode(integrationsProperty) ||
+    !isNode(integrationsProperty.value) ||
+    integrationsProperty.value.type !== "ObjectExpression"
+  ) {
+    return [];
+  }
+
+  const properties = Array.isArray(integrationsProperty.value.properties)
+    ? integrationsProperty.value.properties
+    : [];
+  for (const property of properties) {
+    if (!isNode(property) || property.type !== "ObjectProperty") {
+      continue;
+    }
+
+    const key = getPropertyName(property.key);
+    if (!key) {
+      continue;
+    }
+
+    if (
+      isNode(property.value) &&
+      property.value.type === "CallExpression" &&
+      Array.isArray(property.value.arguments)
+    ) {
+      const pluginId = getCalleeName(property.value.callee);
+      const id = getLiteralString(property.value.arguments[0]);
+      if (pluginId && id) {
+        results.push({ key, pluginId, id });
+      }
+      continue;
+    }
+
+    if (
+      isNode(property.value) &&
+      property.value.type === "Identifier" &&
+      typeof property.value.name === "string"
+    ) {
+      const resolved = variableRefs.get(property.value.name);
+      if (resolved) {
+        results.push({ key, ...resolved });
+      }
+    }
+  }
+
+  return results;
+}
+
+export function extractIntegrationIdsFromSource(source: string): string[] {
+  return extractIntegrationsFromSource(source).map(
+    (integration) => integration.id,
+  );
+}

package/src/extract-api-integrations.test.mts

@@ -1,5 +1,4 @@
 import { describe, expect, it } from "vitest";
-
 import {
   extractIntegrationIdsFromSource,
   extractIntegrationsFromSource,

package/src/flag.ts

@@ -1,5 +1,4 @@
 import { DEFAULT_LINES_FOR_LARGE_STEPS } from "@superblocksteam/util";
-
 import type { FlagBootstrap } from "./types/index.js";
 
 export const signingEnabled = (flags: FlagBootstrap): boolean => {

package/src/index.ts

@@ -3,18 +3,11 @@ export { buildApplication } from "./application-build.mjs";
 export {
   getCurrentBranchInfo,
   uploadApplication,
-  type AuditLogFilters,
   type CodeModeApplicationWrapper,
-  type CreateApplicationResult,
   type CurrentBranch,
-  type DailyUsageRow,
   type GetCommitsResponseBody,
-  type IntegrationFilters,
-  type IntegrationSummary,
   type MultiPageApplicationWrapper,
   type MultiPageApplicationWrapperWithComponents,
-  type PlanSummary,
-  type UsageRecordRow,
 } from "./client.js";
 
 export { FeatureFlags } from "./flag.js";

package/src/parse-sdk-registry.mts

@@ -1,5 +1,4 @@
 import path from "node:path";
-
 import { parseSdkRegistryFromContent } from "@superblocksteam/vite-plugin-file-sync/parsing";
 
 export type RegistryKeyToPath = Map<string, string>;

package/src/parse-sdk-registry.test.mts

@@ -1,7 +1,5 @@
 import path from "node:path";
-
 import { describe, it, expect } from "vitest";
-
 import { parseSdkRegistry } from "./parse-sdk-registry.mjs";
 
 describe("parseSdkRegistry", () => {

package/src/sdk.test.ts

@@ -1,18 +1,17 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
 import {
   CommitType,
   BillingPlan,
   type GetApplicationCommitsResponseBody,
   type GetPublicOrganizationSummaryResponseBody,
 } from "@superblocksteam/shared";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 
-const { fetchApplicationCommits, fetchAuditEvents, fetchOrganizationSummary } =
-  vi.hoisted(() => ({
+const { fetchApplicationCommits, fetchOrganizationSummary } = vi.hoisted(
+  () => ({
     fetchApplicationCommits: vi.fn(),
-    fetchAuditEvents: vi.fn(),
     fetchOrganizationSummary: vi.fn(),
-  }));
+  }),
+);
 
 vi.mock("./client.js", async () => {
   const actual = await vi.importActual("./client.js");
@@ -20,7 +19,6 @@ vi.mock("./client.js", async () => {
   return {
     ...actual,
     fetchApplicationCommits,
-    fetchAuditEvents,
     fetchOrganizationSummary,
   };
 });
@@ -106,81 +104,3 @@ describe("SuperblocksSdk.fetchApplicationCommits", () => {
     });
   });
 });
-
-describe("SuperblocksSdk.fetchAuditEvents", () => {
-  beforeEach(() => {
-    fetchAuditEvents.mockReset();
-  });
-
-  it("delegates audit event requests with OCSF filters", async () => {
-    const expectedResponse = {
-      events: [
-        {
-          activity_id: 5,
-          category_uid: 6,
-          class_uid: 6003,
-          status_id: 1,
-          severity_id: 1,
-          type_uid: 600305,
-          time: 1742428800000,
-          actor: {
-            user: {
-              uid: "user-1",
-            },
-          },
-          resource: {
-            uid: "api-1",
-            type: "API",
-          },
-          metadata: {
-            log_name: "audit_event",
-            version: "1.3.0",
-            product: { name: "Superblocks", vendor_name: "Superblocks" },
-          },
-        },
-      ],
-      next_cursor: "cursor-2",
-    };
-    fetchAuditEvents.mockResolvedValue(expectedResponse);
-
-    const sdk = new SuperblocksSdk(
-      "test-token",
-      "https://staging.superblocks.com",
-      "1.2.3",
-    );
-
-    await expect(
-      sdk.fetchAuditEvents({
-        timeStart: "2025-03-20T00:00:00Z",
-        timeEnd: "2025-03-21T00:00:00Z",
-        classUid: 6003,
-        status: 2,
-        severity: 4,
-        actor: "user-1",
-        resourceType: "API",
-        resourceId: "api-1",
-        search: "deploy",
-        cursor: "cursor-1",
-        limit: 50,
-      }),
-    ).resolves.toEqual(expectedResponse);
-    expect(fetchAuditEvents).toHaveBeenCalledWith({
-      cliVersion: "1.2.3",
-      token: "test-token",
-      superblocksBaseUrl: "https://staging.superblocks.com",
-      filters: {
-        timeStart: "2025-03-20T00:00:00Z",
-        timeEnd: "2025-03-21T00:00:00Z",
-        classUid: 6003,
-        status: 2,
-        severity: 4,
-        actor: "user-1",
-        resourceType: "API",
-        resourceId: "api-1",
-        search: "deploy",
-        cursor: "cursor-1",
-        limit: 50,
-      },
-    });
-  });
-});