@superblocksteam/util 1.14.1 → 2.0.3-next.46

package/src/api-files/index.ts

@@ -0,0 +1,15 @@
+import type * as Api from "./api.mjs" with { "resolution-mode": "import" };
+
+export async function writeApiFiles(
+  ...args: Parameters<typeof Api.writeApiFiles>
+) {
+  const esmFunction = await import("./api.mjs");
+  return esmFunction.writeApiFiles(...args);
+}
+
+export async function readAppApiYamlFile(
+  ...args: Parameters<typeof Api.readAppApiYamlFile>
+) {
+  const esmFunction = await import("./api.mjs");
+  return esmFunction.readAppApiYamlFile(...args);
+}

package/src/api-files/types.ts

@@ -0,0 +1,134 @@
+export type AdditionalStepFiles = {
+  relativePath: string;
+  contents: string;
+  language: keyof Step;
+};
+
+export type ApiRepresentation = {
+  extractLargeSourceFiles: boolean;
+  minLinesForExtraction: number;
+};
+
+export interface ApiWrapper {
+  apiPb: Api;
+  name?: string; //@deprecated this attribute is used for getting a name for backends(jobs and workflows) that were never migrated to the new API version.
+}
+
+/** A signature, as produced by the agent. */
+export interface Signature {
+  /** The id of the key used to sign the data. */
+  keyId: string;
+  /** The actual signature, in base64. */
+  data: string;
+}
+
+export type Api = {
+  metadata: {
+    id: string;
+    name: string;
+    organization: string;
+    timestamps?: {
+      created: string;
+      updated: string;
+      deactivated: boolean;
+    };
+    // These properties are merged in from the v3 api entity
+    creator?: {
+      id: string;
+      name: string;
+    };
+    folder?: string;
+  };
+  blocks?: Block[];
+  trigger: any;
+  signature?: Signature;
+};
+
+export type Block = {
+  name: string;
+  step?: Step;
+  loop?: Loop;
+  tryCatch?: TryCatch;
+  conditional?: Conditional;
+  parallel?: Parallel;
+  stream?: Stream;
+};
+
+export type Step = {
+  integration: string;
+  javascript?: LanguageContent;
+  python?: LanguageContent;
+};
+
+export type Loop = {
+  blocks: Block[];
+  range: string;
+  type: LoopType;
+  variables?: Variables;
+};
+
+export enum LoopType {
+  FOR = "TYPE_FOR",
+  FOR_EACH = "TYPE_FOREACH",
+  WHILE = "TYPE_WHILE",
+  UNSPECIFIED = "TYPE_UNSPECIFIED",
+}
+
+export type TryCatch = {
+  try?: Blocks;
+  catch?: Blocks;
+  finally?: Blocks;
+  variables?: Variables;
+};
+
+export type Conditional = {
+  if?: ConditionalBlockWithCondition;
+  elseIf: ConditionalBlockWithCondition[];
+  else?: Blocks;
+};
+
+export type Blocks = {
+  blocks: Block[];
+};
+
+export type ConditionalBlockWithCondition = Blocks & {
+  condition?: string;
+};
+
+export type Parallel = {
+  static?: {
+    paths: Record<string, Blocks>;
+  };
+  dynamic?: {
+    blocks: Block[];
+    variables?: Variables;
+    paths?: string;
+  };
+  poolSize?: number;
+  wait?: WAIT_TYPE;
+};
+
+export type Stream = {
+  trigger?: StreamTrigger;
+  process?: Blocks;
+  variables?: Variables;
+};
+
+export type StreamTrigger = {
+  name: string;
+  step?: Step;
+};
+
+export enum WAIT_TYPE {
+  ALL = "WAIT_ALL",
+  ANY = "WAIT_NONE",
+  UNSPECIFIED = "WAIT_UNSPECIFIED",
+}
+
+export type Variables = Record<string, string>;
+
+export type LanguageContent = {
+  body: Body;
+};
+
+export type Body = string | { path: string };

package/src/component-configs.ts

@@ -4,9 +4,9 @@ import path from "node:path";
 import * as util from "node:util";
 import * as fs from "fs-extra";
 import * as mimeTypes from "mime-types";
-import { CUSTOM_COMPONENTS_PATH } from "./constants";
-import { generateComponentTypesFile } from "./generate-component-types";
-import { validateCustomComponents } from "./validation";
+import { CUSTOM_COMPONENTS_PATH } from "./constants.js";
+import { generateComponentTypesFile } from "./generate-component-types.js";
+import { validateCustomComponents } from "./validation.js";
 
 const asyncExecFile = util.promisify(execFile);
 

package/src/generate-component-types.ts

@@ -1,5 +1,5 @@
-import { dataTypeDefinions, type DataType } from "./data-types";
-import { ComponentConfig } from "./types";
+import { dataTypeDefinions, type DataType } from "./data-types.js";
+import type { ComponentConfig } from "./types.js";
 
 const indent = (str: string, spaces: number) => {
   const spacesString = " ".repeat(spaces);

package/src/index.ts

@@ -1,11 +1,15 @@
-export * from "./constants";
-export * from "./component-configs";
-export * from "./events";
-export * from "./file-uploader";
-export * from "./login";
-export * from "./resource-configs";
-export * from "./data-types";
-export * from "./types";
-export * from "./identifiers";
-export * from "./localGitRepoState";
-export * from "./unreachable";
+export * from "./constants.js";
+export * from "./component-configs.js";
+export * from "./events.js";
+export * from "./file-uploader.js";
+export * from "./login.js";
+export * from "./resource-configs.js";
+export * from "./data-types.js";
+export * from "./types.js";
+export * from "./identifiers.js";
+export * from "./localGitRepoState.js";
+export * from "./unreachable.js";
+export * from "./api-files/types.js";
+export * from "./api-files/index.js";
+export * from "./api-files/constants.js";
+export * from "./mask-unix-signals.js";

package/src/localGitRepoState.ts

@@ -1,4 +1,4 @@
-import { ComponentEvent } from "./events";
+import type { ComponentEvent } from "./events.js";
 
 export type LocalGitRepoState =
   | { status: "NO_GIT" }

package/src/login.ts

@@ -1,7 +1,7 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
 import * as fs from "fs-extra";
-import { FileAccessError, TOKEN_CONFIG_PATH } from "./constants";
+import { FileAccessError, TOKEN_CONFIG_PATH } from "./constants.js";
 
 type BaseUrl = {
   superblocksBaseUrl: string;

package/src/mask-unix-signals.ts

@@ -0,0 +1,86 @@
+const unixSignalsToMask: NodeJS.Signals[] = ["SIGINT", "SIGTERM", "SIGHUP"];
+
+// The exit code that is used when the process is aborted due to a unix signal
+const exitCode = 254;
+
+export type ActionResult<T> =
+  | { success: true; returnValue: T }
+  | { success: false; error: unknown };
+
+/**
+ * Runs an action with some unix signals being masked. This is useful for actions that should not be interrupted and need
+ * to be allowed to complete or perform some cleanup. If a signal is received, the action will be notified that it should
+ * abort via the `AbortSignal` that is passed to it. The action may or may not choose to abort immediately. The cleanup
+ * action is called after the main action and this happens unconditionally, i.e. regardless of whether a signal was received,
+ * the main action threw an error, or the main action returned a value. The cleanup action is passed the abort signal and the
+ * error (if any) that was thrown by the main action. If a signal was received, the process will exit after the cleanup
+ * action has completed. If the main action threw an error, that error will be thrown again. Otherwise, the main action's
+ * return value is returned. This function can be thought of as a (unix) signal aware version of `try { … } finally { … }`
+ * and `try { … } catch { … } catch { … }`.
+ *
+ * *Note*: This function registers listeners for some unix signals, so it affects the global behavior of the process. Be
+ * careful when using this function in a library.
+ *
+ * @param action - The main action to execute.
+ * @param cleanup - An optional cleanup action to execute when the process is aborted.
+ * @returns The result of the `action`.
+ */
+export async function maskUnixSignals<T>(
+  action: (aborted: AbortSignal) => Promise<T>,
+  cleanup?: (
+    aborted: AbortSignal,
+    actionResult: ActionResult<T>,
+  ) => Promise<void>,
+): Promise<T> {
+  const abortController = new AbortController();
+  const abortSignal = abortController.signal;
+
+  const onUnixSignal = (unixSignal: NodeJS.Signals) => {
+    console.log(`${unixSignal} received, will abort after cleanup`);
+    if (unixSignal === "SIGINT") {
+      if (!abortSignal.aborted) {
+        console.log("Press Ctrl+C again to force abort");
+      } else {
+        console.log("Second SIGINT received, will abort immediately");
+        process.exit(exitCode);
+      }
+    }
+    // Pass the signal as the reason for aborting so that `action` and `cleanup` can know which signal was received
+    abortController.abort(unixSignal);
+  };
+
+  for (const signal of unixSignalsToMask) {
+    process.on(signal, onUnixSignal);
+  }
+  try {
+    let result: ActionResult<T>;
+    try {
+      const returnValue = await action(abortSignal);
+      result = { success: true, returnValue };
+    } catch (err) {
+      result = { success: false, error: err };
+    }
+    try {
+      await cleanup?.(abortSignal, result);
+    } finally {
+      // If the process received a (unix) signal, this takes precedence over any error that was thrown by `action` or
+      // `cleanup`. So we exit here. Otherwise, we let standard JS error handling take over, e.g. an exception
+      // thrown by `cleanup` shadows any exception that was thrown by `action`.
+      if (abortSignal.aborted) {
+        // The process received a (unix) signal, so we exit here.
+        process.exit(exitCode);
+      }
+    }
+    if (!result.success) {
+      // `action` threw an error
+      throw result.error;
+    } else {
+      // `action` threw an error
+      return result.returnValue;
+    }
+  } finally {
+    for (const signal of unixSignalsToMask) {
+      process.off(signal, onUnixSignal);
+    }
+  }
+}

package/src/resource-configs.ts

@@ -1,13 +1,20 @@
 import path from "path";
 import * as fs from "fs-extra";
-import { RESOURCE_CONFIG_PATH } from "./constants";
+import { RESOURCE_CONFIG_PATH } from "./constants.js";
 
 export type SuperblocksMetadata = {
   cliVersion: string;
 };
 
+// Resource type is the type of the resource in the Superblocks platform
 export type SuperblocksResourceType = "APPLICATION" | "BACKEND";
 
+// Resource-specific config
+export type SuperblocksConfigType =
+  | "APPLICATION"
+  | "APPLICATION_V2"
+  | "BACKEND";
+
 export type VersionedResourceConfig = {
   location: string;
   resourceType: SuperblocksResourceType;
@@ -19,6 +26,7 @@ export type SuperblocksResourceConfigMetadata = {
 
 export type SuperblocksResourceConfig = {
   id: string;
+  configType: SuperblocksConfigType;
   metadata?: SuperblocksResourceConfigMetadata;
 };
 
@@ -52,6 +60,10 @@ export type ApiInfo = SourceFilesContanier & {
   name: string;
 };
 
+export type SuperblocksApplicationV2Config = SuperblocksResourceConfig & {
+  configType: "APPLICATION_V2";
+};
+
 export type SuperblocksMonorepoConfig = {
   configType: "ROOT";
   resources: Record<string, VersionedResourceConfig>;
@@ -61,6 +73,7 @@ export type SuperblocksMonorepoConfig = {
 export type SuperblocksConfig =
   | SuperblocksMonorepoConfig
   | SuperblocksApplicationConfig
+  | SuperblocksApplicationV2Config
   | SuperblocksBackendConfig;
 
 /**
@@ -155,6 +168,31 @@ export async function getSuperblocksApplicationConfigIfExists(
   return superblocksConfig as SuperblocksApplicationConfig;
 }
 
+export async function getSuperblocksApplicationV2ConfigJson(
+  applicationPath?: string,
+): Promise<SuperblocksApplicationV2Config> {
+  let superblocksConfig;
+  try {
+    const configPath = applicationPath
+      ? path.join(applicationPath, RESOURCE_CONFIG_PATH)
+      : RESOURCE_CONFIG_PATH;
+    superblocksConfig = await fs.readJSON(configPath);
+  } catch {
+    // no superblocks config file found
+    throw new Error(
+      "This command must be run within a Superblocks app directory.",
+    );
+  }
+
+  if (superblocksConfig.configType !== "APPLICATION_V2") {
+    throw new Error(
+      "Please execute this command within a Superblocks application directory.",
+    );
+  }
+
+  return superblocksConfig as SuperblocksApplicationV2Config;
+}
+
 export async function getSuperblocksBackendConfigIfExists(
   backendPath: string,
 ): Promise<SuperblocksBackendConfig | undefined> {
@@ -204,6 +242,11 @@ export async function getSuperblocksResourceConfigIfExists(): Promise<
   } catch {
     // Noop
   }
+  try {
+    config = await getSuperblocksApplicationV2ConfigJson();
+  } catch {
+    // Noop
+  }
   try {
     config = await getSuperblocksBackendConfigJson();
   } catch {
@@ -211,3 +254,40 @@ export async function getSuperblocksResourceConfigIfExists(): Promise<
   }
   return config;
 }
+
+export function getResourceIdFromUrl(
+  resourceUrl: any,
+): [string, SuperblocksResourceType] {
+  const url = new URL(resourceUrl);
+  if (url.pathname.startsWith("/code-mode")) {
+    // find the first uuid in the url
+    const tokens = url.pathname.split("/");
+    const uuid = tokens.find((token) =>
+      token.match(
+        /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/,
+      ),
+    );
+    if (!uuid) {
+      throw new Error(`Failed to parse resource URL: ${resourceUrl}`);
+    }
+    return [uuid, "APPLICATION"];
+  }
+  if (url.pathname.startsWith("/applications")) {
+    const tokens = url.pathname.split("/");
+    if (tokens.length < 2) {
+      throw new Error(`Failed to parse resource URL: ${resourceUrl}`);
+    }
+    if (tokens[2] === "edit") {
+      return [tokens[3], "APPLICATION"];
+    } else {
+      return [tokens[2], "APPLICATION"];
+    }
+  } else if (
+    url.pathname.startsWith("/workflows") ||
+    url.pathname.startsWith("/scheduled_jobs")
+  ) {
+    return [url.pathname.split("/")[2], "BACKEND"];
+  }
+
+  throw new Error(`Failed to parse resource URL: ${resourceUrl}`);
+}

package/src/types.ts

@@ -1,5 +1,5 @@
-import { type UUID } from "node:crypto";
-import { type DataType } from "./data-types";
+import type { DataType } from "./data-types.js";
+import type { UUID } from "node:crypto";
 
 interface PropertiesPanelDisplay<T extends DataType> {
   /**
@@ -45,16 +45,13 @@ interface PropertiesPanelDisplay<T extends DataType> {
 
   /**
    * The default value should match the dataType of the property.
-   *
-   * When dataType is "any", you must provide a string default value.
-   * Your string will be interpreted based on the controlType, so if you have controlType "js-expr",
-   * you should provide a string that is a valid javascript expression including quotations marks.
    */
-  defaultValue?: T extends "number"
-    ? number
-    : T extends "boolean"
-      ? boolean
-      : string;
+  defaultValue?: T;
+
+  /**
+   * The default value to use when adding a property.
+   */
+  defaultOnAdd?: T;
 }
 
 export interface PropertyForData<T extends DataType> {

package/src/unreachable.ts

@@ -1,3 +1,5 @@
-export function unreachable(value: never): never {
-  throw new TypeError("Encountered impossible value: " + JSON.stringify(value));
+export function unreachable(value: never, errMsg?: string): never {
+  throw new TypeError(
+    errMsg ?? "Encountered impossible value: " + JSON.stringify(value),
+  );
 }

package/src/validation.ts

@@ -1,7 +1,8 @@
-import Ajv, { Schema } from "ajv";
-import { DataValidateFunction } from "ajv/dist/types";
+import Ajv from "ajv";
 import betterAjvErrors from "better-ajv-errors";
-import { isReservedPropertyName, isValidIdentifier } from "./identifiers";
+import { isReservedPropertyName, isValidIdentifier } from "./identifiers.js";
+import type { Schema } from "ajv";
+import type { DataValidateFunction } from "ajv/dist/types";
 
 const ajv = new Ajv();
 

package/tsconfig.json

@@ -1,11 +1,18 @@
 {
   "compilerOptions": {
     "declaration": true,
-    "module": "commonjs",
+    "module": "nodenext",
+    "moduleDetection": "force",
+    "moduleResolution": "nodenext",
+    "isolatedModules": true,
     "outDir": "dist",
     "rootDir": "src",
     "strict": true,
-    "target": "es2019",
+    "composite": true,
+    "target": "es2022",
+    "lib": ["es2022"],
+    "sourceMap": true,
+    "declarationMap": true,
     "esModuleInterop": true,
     "skipLibCheck": true
   },