@superblocksteam/util 0.0.11

package/dist/component-configs.d.ts

@@ -0,0 +1 @@
+export declare function getComponentConfigs(): Promise<Record<string, any>>;

package/dist/component-configs.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getComponentConfigs = void 0;
+const tslib_1 = require("tslib");
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+const node_os_1 = tslib_1.__importDefault(require("node:os"));
+const fs = tslib_1.__importStar(require("fs-extra"));
+const constants_1 = require("./constants");
+const child_process_1 = require("child_process");
+const compileTypeScript = (inputFilePath, outputDir) => {
+    return new Promise((resolve, reject) => {
+        try {
+            const tscPath = require.resolve("typescript/bin/tsc");
+            if (tscPath) {
+                (0, child_process_1.execFile)(tscPath, [node_path_1.default.resolve(inputFilePath), "--outDir", outputDir, "--jsx", "react-jsx", "--target", "es2019", "--esModuleInterop", "true", "--moduleResolution", "node", "--module", "commonjs"], (error, stdout, stderr) => {
+                    if (error) {
+                        // Print any Typescript output to the user, such as errors
+                        console.log(stdout);
+                        reject(`Compilation failed: ${error.message}`);
+                        return;
+                    }
+                    if (stderr) {
+                        reject(`Error during compilation: ${stderr}`);
+                        return;
+                    }
+                    resolve("Compilation successful!");
+                });
+            }
+        }
+        catch (e) {
+            reject(new Error("Could not find TypeScript, please install it globally (npm install -g typescript)"));
+        }
+    });
+};
+async function getFolderPaths() {
+    try {
+        const folderPaths = await fs.readdir(constants_1.CUSTOM_COMPONENTS_PATH, {
+            withFileTypes: true,
+        });
+        // filter out any non-directory items
+        const directories = folderPaths.filter((dirent) => dirent.isDirectory());
+        // map each directory to its path
+        const folderPathsArray = directories.map((dirent) => node_path_1.default.resolve(`${constants_1.CUSTOM_COMPONENTS_PATH}/${dirent.name}`));
+        return folderPathsArray;
+    }
+    catch {
+        throw new Error("Could not access component directory, check your permissions");
+    }
+}
+async function getComponentConfigs() {
+    const folderPaths = await getFolderPaths();
+    const promiseConfigFiles = folderPaths.map(async (ccpath) => {
+        try {
+            const ret = await fs.readJSON(`${ccpath}/config.json`);
+            console.log(`Found component in ${ccpath}`);
+            return ret;
+        }
+        catch (e) {
+            // Noop because there is a fallback
+        }
+        try {
+            // This is a tad complex to explain this hack but here's the context:
+            // We want to be able to hot reload the config.ts file, but we can't import it directly
+            // because it is going to get cached in the module cache and we dont have access to it to clear it
+            // so instead we copy the file to a new location with a random name and import that
+            // this is technically a memory leak, but you shouldnt really have a hot module server running forever
+            const rawPath = `${ccpath}/config.ts`;
+            const fileName = node_path_1.default.resolve(rawPath);
+            const outputDirectory = node_path_1.default.resolve(`${node_os_1.default.tmpdir()}/superblocks/${ccpath}/config.timestamp-${Date.now()}-${Math.random()
+                .toString(16)
+                .slice(2)}`);
+            await compileTypeScript(fileName, outputDirectory);
+            console.log(`Typescript compiled to ${ccpath}`);
+            const ret = (await Promise.resolve(`${outputDirectory + "/config.js"}`).then(s => tslib_1.__importStar(require(s)))).default;
+            console.log(`Found component in ${ccpath}`);
+            return ret;
+        }
+        catch (e) {
+            console.error(e);
+            console.error(e.message);
+            throw e;
+        }
+    });
+    const configFiles = (await Promise.all(promiseConfigFiles))
+        .filter((file) => file !== null)
+        .reduce((acc, config) => {
+        acc[config.id] = config;
+        return acc;
+    }, {});
+    return configFiles;
+}
+exports.getComponentConfigs = getComponentConfigs;

package/dist/constants.d.ts

@@ -0,0 +1,9 @@
+export declare const SUPERBLOCKS_HOME_FOLDER_NAME = ".superblocks";
+export declare const TOKEN_CONFIG_PATH = ".superblocks/auth.json";
+export declare const RESOURCE_CONFIG_PATH = ".superblocks/superblocks.json";
+export declare const ROOT_CONFIG_RELATIVE_PATH = "../..";
+export declare const CUSTOM_COMPONENTS_PATH = "components";
+export declare const ERROR_FILE_ACCESS = "FileAccessError";
+export declare class FileAccessError extends Error {
+    constructor(message: string);
+}

package/dist/constants.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileAccessError = exports.ERROR_FILE_ACCESS = exports.CUSTOM_COMPONENTS_PATH = exports.ROOT_CONFIG_RELATIVE_PATH = exports.RESOURCE_CONFIG_PATH = exports.TOKEN_CONFIG_PATH = exports.SUPERBLOCKS_HOME_FOLDER_NAME = void 0;
+exports.SUPERBLOCKS_HOME_FOLDER_NAME = ".superblocks";
+exports.TOKEN_CONFIG_PATH = ".superblocks/auth.json";
+exports.RESOURCE_CONFIG_PATH = ".superblocks/superblocks.json";
+/* It's a relative path from resource's directory to a project's root
+├── apps
+│   ├── <app_name>
+│   │   ├── apis
+│   │   │   ├── <api_name1>
+...
+│   │   │   ├── <api_nameN>
+│   │   ├── application.yaml
+│   │   └── page.yaml
+├── backends
+│   └── <scheduled job|workflow_name>
+│       └── api.yaml
+*/
+exports.ROOT_CONFIG_RELATIVE_PATH = "../..";
+exports.CUSTOM_COMPONENTS_PATH = "components";
+exports.ERROR_FILE_ACCESS = "FileAccessError";
+class FileAccessError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = exports.ERROR_FILE_ACCESS;
+    }
+}
+exports.FileAccessError = FileAccessError;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./constants";
+export * from "./component-configs";
+export * from "./login";
+export * from "./resource-configs";

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./constants"), exports);
+tslib_1.__exportStar(require("./component-configs"), exports);
+tslib_1.__exportStar(require("./login"), exports);
+tslib_1.__exportStar(require("./resource-configs"), exports);

package/dist/login.d.ts

@@ -0,0 +1,8 @@
+type TokenWithBaseUrl = {
+    token: string;
+    superblocksBaseUrl: string;
+};
+export declare function saveApiToken(token: string, superblocksBaseUrl: string): Promise<void>;
+export declare function getLocalTokenWithUrlIfExists(): Promise<TokenWithBaseUrl | undefined>;
+export declare function getLocalTokenWithUrl(): Promise<TokenWithBaseUrl>;
+export {};

package/dist/login.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocalTokenWithUrl = exports.getLocalTokenWithUrlIfExists = exports.saveApiToken = void 0;
+const tslib_1 = require("tslib");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const fs = tslib_1.__importStar(require("fs-extra"));
+const constants_1 = require("./constants");
+async function saveApiToken(token, superblocksBaseUrl) {
+    try {
+        await fs.ensureDir((0, node_path_1.join)((0, node_os_1.homedir)(), ".superblocks"));
+        await fs.writeJSON((0, node_path_1.join)((0, node_os_1.homedir)(), constants_1.TOKEN_CONFIG_PATH), {
+            token,
+            superblocksBaseUrl,
+        });
+    }
+    catch {
+        throw new constants_1.FileAccessError("Could not save token");
+    }
+}
+exports.saveApiToken = saveApiToken;
+async function getLocalTokenWithUrlIfExists() {
+    try {
+        return await getLocalTokenWithUrl();
+    }
+    catch {
+        return undefined;
+    }
+}
+exports.getLocalTokenWithUrlIfExists = getLocalTokenWithUrlIfExists;
+async function getLocalTokenWithUrl() {
+    try {
+        const tokenConfig = await fs.readJSON((0, node_path_1.join)((0, node_os_1.homedir)(), constants_1.TOKEN_CONFIG_PATH));
+        return {
+            token: tokenConfig.token,
+            superblocksBaseUrl: tokenConfig.superblocksBaseUrl,
+        };
+    }
+    catch {
+        throw new Error("No local API key found");
+    }
+}
+exports.getLocalTokenWithUrl = getLocalTokenWithUrl;

package/dist/resource-configs.d.ts

@@ -0,0 +1,36 @@
+export type SuperblocksMetadata = {
+    cliVersion: string;
+    remote: string;
+    lastUpdated: number;
+    created: number;
+};
+export type VersionedResourceConfig = {
+    location: string;
+    lastUpdated: number;
+    resourceType: "APPLICATION" | "BACKEND";
+};
+export type SuperblocksResourceConfig = {
+    id: string;
+};
+export type SuperblocksBackendConfig = SuperblocksResourceConfig & {
+    configType: "BACKEND";
+};
+export type SuperblocksApplicationConfig = SuperblocksResourceConfig & {
+    configType: "APPLICATION";
+    defaultPageId: string;
+    apis: Record<string, string>;
+};
+export type SuperblocksMonorepoConfig = {
+    configType: "ROOT";
+    resources: Record<string, VersionedResourceConfig>;
+    metadata: SuperblocksMetadata;
+};
+export type SuperblocksConfig = SuperblocksMonorepoConfig | SuperblocksApplicationConfig | SuperblocksBackendConfig;
+/**
+ * Get the Superblocks config file from the current directory (and optionally) hierarchy
+ * @param checkParentDir Whether to recursively check the parent directory for a Superblocks config file
+ */
+export declare function getSuperblocksMonorepoConfigJson(checkParentDir?: boolean, pathPrefix?: string): Promise<[SuperblocksMonorepoConfig, string]>;
+export declare function getSuperblocksApplicationConfigJson(): Promise<SuperblocksApplicationConfig>;
+export declare function getSuperblocksBackendConfigJson(): Promise<SuperblocksBackendConfig>;
+export declare function getSuperblocksResourceConfigIfExists(): Promise<SuperblocksResourceConfig | undefined>;

package/dist/resource-configs.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSuperblocksResourceConfigIfExists = exports.getSuperblocksBackendConfigJson = exports.getSuperblocksApplicationConfigJson = exports.getSuperblocksMonorepoConfigJson = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs-extra"));
+const constants_1 = require("./constants");
+/**
+ * Get the Superblocks config file from the current directory (and optionally) hierarchy
+ * @param checkParentDir Whether to recursively check the parent directory for a Superblocks config file
+ */
+async function getSuperblocksMonorepoConfigJson(checkParentDir = false, pathPrefix = "") {
+    let superblocksConfig;
+    if (pathPrefix && !fs.existsSync(pathPrefix)) {
+        throw new Error("No Superblocks config file found in current directory hierarchy " +
+            pathPrefix);
+    }
+    try {
+        superblocksConfig = await fs.readJSON(pathPrefix + constants_1.RESOURCE_CONFIG_PATH);
+        if (superblocksConfig.configType !== "ROOT") {
+            throw new Error("Not the root Superblocks config file");
+        }
+        return [
+            superblocksConfig,
+            pathPrefix + constants_1.RESOURCE_CONFIG_PATH,
+        ];
+    }
+    catch {
+        if (!checkParentDir) {
+            // no superblocks config file found
+            throw new Error("No Superblocks config file found in current directory " +
+                pathPrefix +
+                constants_1.RESOURCE_CONFIG_PATH);
+        }
+        return getSuperblocksMonorepoConfigJson(true, "../" + pathPrefix);
+    }
+}
+exports.getSuperblocksMonorepoConfigJson = getSuperblocksMonorepoConfigJson;
+async function getSuperblocksApplicationConfigJson() {
+    let superblocksConfig;
+    try {
+        superblocksConfig = await fs.readJSON(constants_1.RESOURCE_CONFIG_PATH);
+    }
+    catch {
+        // no superblocks config file found
+        throw new Error("This command must be run within a Superblocks app directory.");
+    }
+    if (superblocksConfig.configType !== "APPLICATION") {
+        throw new Error("Please execute this command within a Superblocks application directory.");
+    }
+    return superblocksConfig;
+}
+exports.getSuperblocksApplicationConfigJson = getSuperblocksApplicationConfigJson;
+async function getSuperblocksBackendConfigJson() {
+    let superblocksConfig;
+    try {
+        superblocksConfig = await fs.readJSON(constants_1.RESOURCE_CONFIG_PATH);
+    }
+    catch {
+        // no superblocks config file found
+        throw new Error("This command must be run within a Superblocks backend resource (workflow/job) directory.");
+    }
+    if (superblocksConfig.configType !== "BACKEND") {
+        throw new Error("Please execute this command within a Superblocks backend resource (workflow/job) directory.");
+    }
+    return superblocksConfig;
+}
+exports.getSuperblocksBackendConfigJson = getSuperblocksBackendConfigJson;
+async function getSuperblocksResourceConfigIfExists() {
+    let config;
+    try {
+        config = await getSuperblocksApplicationConfigJson();
+    }
+    catch { }
+    try {
+        config = await getSuperblocksBackendConfigJson();
+    }
+    catch { }
+    return config;
+}
+exports.getSuperblocksResourceConfigIfExists = getSuperblocksResourceConfigIfExists;

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@superblocksteam/util",
+  "version": "0.0.11",
+  "main": "dist/index.js",
+  "homepage": "https://www.superblocks.com",
+  "scripts": {
+    "dev": "tsc --watch",
+    "build": "tsc --build",
+    "clean": "npm run clean:build && rm -rf node_modules",
+    "clean:build": "tsc --build --clean && rm -rf dist tsconfig.tsbuildinfo"
+  },
+  "license": "Superblocks Community Software License",
+  "description": "",
+  "devDependencies": {
+    "typescript": "^5.0.4"
+  }
+}

package/src/component-configs.ts

@@ -0,0 +1,97 @@
+import path from "node:path";
+import os from "node:os";
+import * as fs from "fs-extra";
+import { CUSTOM_COMPONENTS_PATH } from "./constants";
+import { execFile } from "child_process";
+
+const compileTypeScript = (inputFilePath: string, outputDir: string) => {
+  return new Promise((resolve, reject) => {
+    try {
+      const tscPath = require.resolve("typescript/bin/tsc");
+      if (tscPath) {
+        execFile(
+          tscPath,
+          [path.resolve(inputFilePath), "--outDir", outputDir, "--jsx", "react-jsx", "--target", "es2019", "--esModuleInterop", "true", "--moduleResolution", "node", "--module", "commonjs"],
+          (error, stdout, stderr) => {
+            if (error) {
+              // Print any Typescript output to the user, such as errors
+              console.log(stdout);
+              reject(`Compilation failed: ${error.message}`);
+              return;
+            }
+            if (stderr) {
+              reject(`Error during compilation: ${stderr}`);
+              return;
+            }
+            resolve("Compilation successful!");
+          }
+        );
+      }
+    } catch (e) {
+      reject(new Error("Could not find TypeScript, please install it globally (npm install -g typescript)"));
+    }
+  });
+};
+
+async function getFolderPaths() {
+  try {
+    const folderPaths = await fs.readdir(CUSTOM_COMPONENTS_PATH, {
+      withFileTypes: true,
+    });
+    // filter out any non-directory items
+    const directories = folderPaths.filter((dirent) => dirent.isDirectory());
+    // map each directory to its path
+    const folderPathsArray = directories.map((dirent) =>
+      path.resolve(`${CUSTOM_COMPONENTS_PATH}/${dirent.name}`)
+    );
+    return folderPathsArray;
+  } catch {
+    throw new Error(
+      "Could not access component directory, check your permissions"
+    );
+  }
+}
+
+export async function getComponentConfigs(): Promise<Record<string, any>> {
+  const folderPaths = await getFolderPaths();
+  const promiseConfigFiles = folderPaths.map(async (ccpath) => {
+    try {
+      const ret = await fs.readJSON(`${ccpath}/config.json`);
+      console.log(`Found component in ${ccpath}`);
+      return ret;
+    } catch (e: any) {
+      // Noop because there is a fallback
+    }
+
+    try {
+      // This is a tad complex to explain this hack but here's the context:
+      // We want to be able to hot reload the config.ts file, but we can't import it directly
+      // because it is going to get cached in the module cache and we dont have access to it to clear it
+      // so instead we copy the file to a new location with a random name and import that
+      // this is technically a memory leak, but you shouldnt really have a hot module server running forever
+      const rawPath = `${ccpath}/config.ts`;
+      const fileName = path.resolve(rawPath);
+      const outputDirectory = path.resolve(
+        `${os.tmpdir()}/superblocks/${ccpath}/config.timestamp-${Date.now()}-${Math.random()
+          .toString(16)
+          .slice(2)}`
+      );
+      await compileTypeScript(fileName, outputDirectory);
+      console.log(`Typescript compiled to ${ccpath}`);
+      const ret = (await import(outputDirectory + "/config.js")).default;
+      console.log(`Found component in ${ccpath}`);
+      return ret;
+    } catch (e: any) {
+      console.error(e);
+      console.error(e.message);
+      throw e;
+    }
+  });
+  const configFiles = (await Promise.all(promiseConfigFiles))
+    .filter((file) => file !== null)
+    .reduce((acc, config) => {
+      acc[config.id] = config;
+      return acc;
+    }, {});
+  return configFiles;
+}

package/src/constants.ts

@@ -0,0 +1,28 @@
+export const SUPERBLOCKS_HOME_FOLDER_NAME = ".superblocks";
+export const TOKEN_CONFIG_PATH = ".superblocks/auth.json";
+export const RESOURCE_CONFIG_PATH = ".superblocks/superblocks.json";
+
+/* It's a relative path from resource's directory to a project's root
+├── apps
+│   ├── <app_name>
+│   │   ├── apis
+│   │   │   ├── <api_name1>
+...
+│   │   │   ├── <api_nameN>
+│   │   ├── application.yaml
+│   │   └── page.yaml
+├── backends
+│   └── <scheduled job|workflow_name>
+│       └── api.yaml
+*/
+export const ROOT_CONFIG_RELATIVE_PATH = "../..";
+
+export const CUSTOM_COMPONENTS_PATH = "components";
+
+export const ERROR_FILE_ACCESS = "FileAccessError";
+export class FileAccessError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = ERROR_FILE_ACCESS;
+  }
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from "./constants";
+export * from "./component-configs";
+export * from "./login";
+export * from "./resource-configs";

package/src/login.ts

@@ -0,0 +1,43 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import * as fs from "fs-extra";
+import { FileAccessError, TOKEN_CONFIG_PATH } from "./constants";
+
+type TokenWithBaseUrl = {
+  token: string;
+  superblocksBaseUrl: string;
+};
+
+export async function saveApiToken(token: string, superblocksBaseUrl: string) {
+  try {
+    await fs.ensureDir(join(homedir(), ".superblocks"));
+    await fs.writeJSON(join(homedir(), TOKEN_CONFIG_PATH), {
+      token,
+      superblocksBaseUrl,
+    });
+  } catch {
+    throw new FileAccessError("Could not save token");
+  }
+}
+
+export async function getLocalTokenWithUrlIfExists(): Promise<
+  TokenWithBaseUrl | undefined
+> {
+  try {
+    return await getLocalTokenWithUrl();
+  } catch {
+    return undefined;
+  }
+}
+
+export async function getLocalTokenWithUrl(): Promise<TokenWithBaseUrl> {
+  try {
+    const tokenConfig = await fs.readJSON(join(homedir(), TOKEN_CONFIG_PATH));
+    return {
+      token: tokenConfig.token as string,
+      superblocksBaseUrl: tokenConfig.superblocksBaseUrl as string,
+    };
+  } catch {
+    throw new Error("No local API key found");
+  }
+}

package/src/resource-configs.ts

@@ -0,0 +1,131 @@
+import * as fs from "fs-extra";
+import { RESOURCE_CONFIG_PATH } from "./constants";
+
+export type SuperblocksMetadata = {
+  cliVersion: string;
+  remote: string;
+  lastUpdated: number;
+  created: number;
+};
+
+export type VersionedResourceConfig = {
+  location: string;
+  lastUpdated: number;
+  resourceType: "APPLICATION" | "BACKEND";
+};
+
+export type SuperblocksResourceConfig = {
+  id: string;
+};
+
+export type SuperblocksBackendConfig = SuperblocksResourceConfig & {
+  configType: "BACKEND";
+};
+
+export type SuperblocksApplicationConfig = SuperblocksResourceConfig & {
+  configType: "APPLICATION";
+  defaultPageId: string;
+  apis: Record<string, string>;
+};
+
+export type SuperblocksMonorepoConfig = {
+  configType: "ROOT";
+  resources: Record<string, VersionedResourceConfig>;
+  metadata: SuperblocksMetadata;
+};
+
+export type SuperblocksConfig =
+  | SuperblocksMonorepoConfig
+  | SuperblocksApplicationConfig
+  | SuperblocksBackendConfig;
+
+/**
+ * Get the Superblocks config file from the current directory (and optionally) hierarchy
+ * @param checkParentDir Whether to recursively check the parent directory for a Superblocks config file
+ */
+export async function getSuperblocksMonorepoConfigJson(
+  checkParentDir = false,
+  pathPrefix = ""
+): Promise<[SuperblocksMonorepoConfig, string]> {
+  let superblocksConfig;
+  if (pathPrefix && !fs.existsSync(pathPrefix)) {
+    throw new Error(
+      "No Superblocks config file found in current directory hierarchy " +
+        pathPrefix
+    );
+  }
+
+  try {
+    superblocksConfig = await fs.readJSON(pathPrefix + RESOURCE_CONFIG_PATH);
+    if (superblocksConfig.configType !== "ROOT") {
+      throw new Error("Not the root Superblocks config file");
+    }
+    return [
+      superblocksConfig as SuperblocksMonorepoConfig,
+      pathPrefix + RESOURCE_CONFIG_PATH,
+    ];
+  } catch {
+    if (!checkParentDir) {
+      // no superblocks config file found
+      throw new Error(
+        "No Superblocks config file found in current directory " +
+          pathPrefix +
+          RESOURCE_CONFIG_PATH
+      );
+    }
+    return getSuperblocksMonorepoConfigJson(true, "../" + pathPrefix);
+  }
+}
+
+export async function getSuperblocksApplicationConfigJson(): Promise<SuperblocksApplicationConfig> {
+  let superblocksConfig;
+  try {
+    superblocksConfig = await fs.readJSON(RESOURCE_CONFIG_PATH);
+  } catch {
+    // no superblocks config file found
+    throw new Error(
+      "This command must be run within a Superblocks app directory."
+    );
+  }
+
+  if (superblocksConfig.configType !== "APPLICATION") {
+    throw new Error(
+      "Please execute this command within a Superblocks application directory."
+    );
+  }
+
+  return superblocksConfig as SuperblocksApplicationConfig;
+}
+
+export async function getSuperblocksBackendConfigJson(): Promise<SuperblocksBackendConfig> {
+  let superblocksConfig;
+  try {
+    superblocksConfig = await fs.readJSON(RESOURCE_CONFIG_PATH);
+  } catch {
+    // no superblocks config file found
+    throw new Error(
+      "This command must be run within a Superblocks backend resource (workflow/job) directory."
+    );
+  }
+
+  if (superblocksConfig.configType !== "BACKEND") {
+    throw new Error(
+      "Please execute this command within a Superblocks backend resource (workflow/job) directory."
+    );
+  }
+
+  return superblocksConfig as SuperblocksBackendConfig;
+}
+
+export async function getSuperblocksResourceConfigIfExists(): Promise<
+  SuperblocksResourceConfig | undefined
+> {
+  let config: SuperblocksResourceConfig | undefined;
+  try {
+    config = await getSuperblocksApplicationConfigJson();
+  } catch {}
+  try {
+    config = await getSuperblocksBackendConfigJson();
+  } catch {}
+  return config;
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "declaration": true,
+    "importHelpers": true,
+    "module": "commonjs",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "target": "es2019",
+    "esModuleInterop": true
+  },
+  "include": ["src/**/*"]
+}

package/tsup.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  name: "tsup",
+  target: "node16",
+  entryPoints: ["./src/index.ts"],
+  format: ["cjs", "esm"],
+});