attio 0.0.1-experimental.20251001 → 0.0.1-experimental.20251001.1

package/lib/build/client/create-client-build-config.js

@@ -1,6 +1,7 @@
 import globalExternals from "@fal-works/esbuild-plugin-global-externals";
+import { proxyBlockModulesPlugin } from "../proxy-block-modules-plugin.js";
 import { proxyServerModulesPlugin } from "../proxy-server-modules-plugin.js";
-export function createClientBuildConfig({ srcDir, entryPoint, }) {
+export function createClientBuildConfig({ appDir, srcDir, entryPoint, workflowBlockModulesRef, }) {
     return {
         entryPoints: [entryPoint],
         logLevel: "silent",
@@ -50,6 +51,10 @@ export function createClientBuildConfig({ srcDir, entryPoint, }) {
                         "useTransition",
                     ],
                 },
+                attio: {
+                    varName: "ATTIO_ROOT_SDK",
+                    type: "cjs",
+                },
                 "attio/client": {
                     varName: "ATTIO_CLIENT_EXTENSION_SDK",
                     type: "cjs",
@@ -60,6 +65,7 @@ export function createClientBuildConfig({ srcDir, entryPoint, }) {
                 },
             }),
             proxyServerModulesPlugin({ srcDir }),
+            proxyBlockModulesPlugin({ appDir, workflowBlockModulesRef }),
         ],
     };
 }

package/lib/build/client/generate-client-entry.js

@@ -2,6 +2,8 @@ import fs from "fs/promises";
 import path from "path";
 import { Project } from "ts-morph";
 import { complete, errored, fromPromise, isComplete } from "@attio/fetchable-npm";
+import { APP_SETTINGS_FILENAME } from "../../constants/settings-files.js";
+import { USE_APP_TS } from "../../env.js";
 import { getAppEntryPoint } from "../../util/get-app-entry-point.js";
 const ASSET_FILE_EXTENSIONS = ["png"];
 export async function generateClientEntry({ srcDirAbsolute, assetsDirAbsolute, }) {
@@ -31,6 +33,11 @@ export async function generateClientEntry({ srcDirAbsolute, assetsDirAbsolute, }
         path: path.join(assetsDirAbsolute, relativeAssetPath),
         name: relativeAssetPath,
     }));
+    const initSettingsJS = `
+        import appSettingsSchema from ${JSON.stringify(path.join(srcDirAbsolute, APP_SETTINGS_FILENAME))}
+
+        registerSettingsSchema(appSettingsSchema)
+    `;
     const importAppJS = `
         import {app} from ${JSON.stringify(appEntryPoint.path)}
     `;
@@ -77,6 +84,8 @@ export async function generateClientEntry({ srcDirAbsolute, assetsDirAbsolute, }
         ${importAppJS}
         ${importAssetsJS}
 
+        ${USE_APP_TS ? initSettingsJS : ""}
+
         ${registerSurfacesJS}
 
         ${registerAssetsJS}

package/lib/build/get-file-exports.js

@@ -9,6 +9,5 @@ export async function getFileExports(filePath) {
     const content = contentResult.value.toString();
     const tsProject = new Project({ useInMemoryFileSystem: true });
     const appSourceFile = tsProject.createSourceFile(filePath, content);
-    const exportsMap = appSourceFile.getExportedDeclarations();
-    return complete(new Set(exportsMap.keys()));
+    return complete(appSourceFile.getExportedDeclarations());
 }

package/lib/build/proxy-block-modules-plugin.js

@@ -0,0 +1,68 @@
+import path from "path";
+function getBlockModuleProxy(modulePath, workflowBlockModulesRef) {
+    let counter = 0;
+    const exports = new Map();
+    for (const { execute, schema, activate, deactivate, } of workflowBlockModulesRef.current.values()) {
+        for (const handler of [execute, activate, deactivate]) {
+            if (!handler || handler.path !== modulePath) {
+                continue;
+            }
+            if (handler.export === "default") {
+                exports.set("default", `export default async function() {
+    throw new Error("Exports from *.block.ts files cannot be called from the client.")
+}`);
+            }
+            else {
+                exports.set(handler.export, `export async function ${handler.export}() {
+    throw new Error("Exports from *.block.ts files cannot be called from the client.")
+}`);
+            }
+        }
+        if (schema && schema.path === modulePath) {
+            if (schema.export === "default") {
+                let name;
+                do {
+                    name = `schema_${counter++}`;
+                } while (!exports.has(name));
+                exports.set("default", `const ${name} = new Proxy({}, {
+    get() {
+        throw new Error("Exports from *.block.ts files cannot be called from the client.");
+    }
+});
+
+export default ${name};`);
+            }
+            else {
+                exports.set(schema.export, `export const ${schema.export} = new Proxy({}, {
+    get() {
+        throw new Error("Exports from *.block.ts files cannot be called from the client.");
+    }
+});`);
+            }
+        }
+    }
+    return [...exports.values()].join("\n");
+}
+const PLUGIN_NAME = "proxy-block-modules-plugin";
+export function proxyBlockModulesPlugin({ appDir, workflowBlockModulesRef, }) {
+    return {
+        name: PLUGIN_NAME,
+        setup(build) {
+            build.onResolve({ filter: /\.block$/ }, (args) => {
+                const modulePath = path.relative(appDir, path.resolve(args.resolveDir, args.path)) + ".ts";
+                return {
+                    path: args.path,
+                    namespace: PLUGIN_NAME,
+                    pluginData: { modulePath },
+                };
+            });
+            build.onLoad({ filter: /.*/, namespace: PLUGIN_NAME }, async (args) => {
+                const pluginData = args.pluginData;
+                return {
+                    contents: getBlockModuleProxy(pluginData.modulePath, workflowBlockModulesRef),
+                    loader: "js",
+                };
+            });
+        },
+    };
+}

package/lib/build/server/create-server-build-config.js

@@ -7,6 +7,10 @@ export function createServerBuildConfig(entryPoint) {
         format: "esm",
         plugins: [
             globalExternals({
+                attio: {
+                    varName: "ATTIO_ROOT_SDK",
+                    type: "cjs",
+                },
                 "attio/server": {
                     varName: "ATTIO_SERVER_APP_SDK",
                     type: "cjs",

package/lib/build/server/find-workflow-block-server-modules.js

@@ -1,37 +1,307 @@
-import fs from "fs/promises";
-import path from "path";
-import { combineAsync, complete, errored, fromPromise, isErrored, map, } from "@attio/fetchable-npm";
-import { getFileExports } from "../get-file-exports.js";
-async function processFile(file) {
-    const filePath = path.join(file.parentPath, file.name);
-    const parts = file.name.split(".block.ts");
-    if (parts.length !== 2 || parts[1] !== "" || parts[0] === "") {
-        return complete([]);
-    }
-    const blockId = parts[0];
-    const exports = await getFileExports(path.join(file.parentPath, file.name));
-    if (isErrored(exports)) {
-        return errored({
-            code: "UNABLE_TO_PARSE_EXPORTS",
-            path: filePath,
-            cause: exports.error.cause,
+import fs from "node:fs";
+import { parse } from "@typescript-eslint/parser";
+import { analyze } from "@typescript-eslint/scope-manager";
+import { walk } from "zimmerframe";
+import { complete, errored } from "@attio/fetchable-npm";
+import { getAppEntryPoint } from "../../util/get-app-entry-point.js";
+function checkPath(path, doesModuleExist) {
+    if (doesModuleExist(path)) {
+        return path;
+    }
+    return null;
+}
+function resolvePathWithExtension(path, doesModuleExist) {
+    return (checkPath(path + ".ts", doesModuleExist) ||
+        checkPath(path + ".tsx", doesModuleExist) ||
+        checkPath(path + ".js", doesModuleExist));
+}
+function loadModule(sourcePath, currPath, helpers) {
+    const absolutePath = resolveAbsolutePath(sourcePath, currPath);
+    const fullPath = resolvePathWithExtension(absolutePath, helpers.doesModuleExist);
+    if (!fullPath) {
+        throw new Error(`Unable to resolve path for module ${sourcePath} from ${currPath}`);
+    }
+    const modules = helpers.modules;
+    if (modules.has(fullPath)) {
+        return modules.get(fullPath);
+    }
+    const content = helpers.getModuleSource(fullPath);
+    const ast = parse(content, {
+        range: true,
+        jsx: true,
+    });
+    const scopeManager = analyze(ast, {
+        sourceType: "module",
+    });
+    const moduleScope = scopeManager.acquire(ast, true);
+    const namedExports = new Map();
+    const module = {
+        content,
+        ast,
+        scope: moduleScope,
+        namedExports,
+        path: fullPath,
+    };
+    modules.set(fullPath, module);
+    walk(ast, null, {
+        ExportNamedDeclaration(node) {
+            if (node.declaration?.type === "VariableDeclaration" &&
+                node.declaration.declarations.length === 1 &&
+                node.declaration.declarations[0].type === "VariableDeclarator" &&
+                node.declaration.declarations[0].id.type === "Identifier") {
+                const declaration = node.declaration.declarations[0];
+                const id = declaration.id;
+                const init = declaration.init;
+                if (init?.type === "Identifier") {
+                    const resolved = resolveIdentifierToValue(init, moduleScope);
+                    if (resolved?.type !== "ImportBinding") {
+                        namedExports.set(id.name, declaration.init);
+                        return;
+                    }
+                }
+                namedExports.set(id.name, declaration.init);
+            }
+            if (node?.specifiers) {
+                for (const specifier of node.specifiers) {
+                    if (specifier.type === "ExportSpecifier" &&
+                        specifier.exported.type === "Identifier" &&
+                        specifier.local.type === "Identifier") {
+                        if (node.source !== null) {
+                            namedExports.set(specifier.exported.name, node);
+                        }
+                        else {
+                            const resolved = resolveIdentifierToValue(specifier.local, moduleScope);
+                            namedExports.set(specifier.exported.name, resolved);
+                        }
+                    }
+                }
+            }
+        },
+    });
+    return module;
+}
+function resolveIdentifierToValue(node, scope) {
+    const variable = scope.set.get(node.name);
+    if (!variable) {
+        throw new Error(`Unable to find variable ${node.name} in scope`);
+    }
+    if (variable.defs.length !== 1) {
+        throw new Error(`Expected exactly one definition for variable ${node.name}, found ${variable.defs.length}`);
+    }
+    const def = variable.defs[0];
+    if (def.node.type === "VariableDeclarator") {
+        return def.node.init;
+    }
+    if (def.type == "ImportBinding") {
+        return def;
+    }
+    return null;
+}
+function resolveAbsolutePath(sourcePath, currPath) {
+    if (sourcePath.startsWith(".")) {
+        const currDir = currPath.split("/").slice(0, -1).join("/");
+        const combinedPath = currDir + "/" + sourcePath;
+        const parts = combinedPath.split("/");
+        const resolvedParts = [];
+        for (const part of parts) {
+            if (part === "..") {
+                resolvedParts.pop();
+            }
+            else if (part !== ".") {
+                resolvedParts.push(part);
+            }
+        }
+        return resolvedParts.join("/");
+    }
+    return sourcePath;
+}
+function captureImportPath(name, node, scope, currPath, helpers) {
+    const importValue = node.type === "Identifier" ? resolveIdentifierToValue(node, scope) : node;
+    if (!importValue ||
+        (importValue.type !== "ImportBinding" && importValue.type !== "ExportNamedDeclaration")) {
+        throw new Error(`Expected parent of import binding to be an import binding`);
+    }
+    const importDeclaration = importValue.type === "ExportNamedDeclaration"
+        ? importValue
+        : importValue.parent;
+    const sourcePath = importDeclaration.source.value;
+    let absolutePath = resolveAbsolutePath(sourcePath, currPath);
+    if (sourcePath.endsWith(".server")) {
+        throw new Error(`Unexpected .server import, did you mean to import "${name}" from a .block file?`);
+    }
+    if (!sourcePath.endsWith(".block") &&
+        !sourcePath.endsWith(".block.ts") &&
+        !sourcePath.endsWith(".block.tsx") &&
+        !sourcePath.endsWith(".block.js")) {
+        const module = loadModule(sourcePath, absolutePath, helpers);
+        if (!module.namedExports.has(name)) {
+            throw new Error(`Unable to find named export ${name} in module ${sourcePath}`);
+        }
+        const value = module.namedExports.get(name);
+        const scope = module.scope;
+        const path = module.path;
+        return captureImportPath(name, value, scope, path, helpers);
+    }
+    let targetExport = name;
+    if (importValue.type === "ImportBinding" && importValue.name.name !== name) {
+        targetExport = importValue.name.name;
+    }
+    absolutePath = resolvePathWithExtension(absolutePath, helpers.doesModuleExist) || absolutePath;
+    return { path: absolutePath, export: targetExport };
+}
+function visitBlock(node, scope, result, currPath, helpers) {
+    if (node.type === "Identifier") {
+        let targetScope = scope;
+        let value = resolveIdentifierToValue(node, scope);
+        let targetPath = currPath;
+        if (value?.type === "ImportBinding") {
+            const importDeclaration = value.parent;
+            const module = loadModule(importDeclaration.source.value, currPath, helpers);
+            const local = value.name.name;
+            const specififier = importDeclaration.specifiers.find((s) => s.local.name === local);
+            const name = (specififier
+                ?.imported).name;
+            if (!module.namedExports.has(name)) {
+                throw new Error(`Unable to find named export ${name} in module ${importDeclaration.source.value}`);
+            }
+            value = module.namedExports.get(name);
+            targetScope = module.scope;
+            targetPath = module.path;
+        }
+        if (!value || value.type !== "ObjectExpression") {
+            throw new Error(`Expected variable ${node.name} to have an initializer`);
+        }
+        visitBlock(value, targetScope, result, targetPath, helpers);
+        return;
+    }
+    if (node.type === "ObjectExpression") {
+        let id;
+        let execute;
+        let schema;
+        let activate;
+        let deactivate;
+        for (const property of node.properties) {
+            if (property.type !== "Property" || property.key.type !== "Identifier") {
+                continue;
+            }
+            const name = property.key.name;
+            if (name === "id") {
+                if (property.value.type !== "Literal" || typeof property.value.value !== "string") {
+                    throw new Error("Expected block id to be a string literal");
+                }
+                id = property.value.value;
+            }
+            else if (name === "execute") {
+                execute = captureImportPath(name, property.value, scope, currPath, helpers);
+            }
+            else if (name === "schema") {
+                schema = captureImportPath(name, property.value, scope, currPath, helpers);
+            }
+            else if (name === "activate") {
+                activate = captureImportPath(name, property.value, scope, currPath, helpers);
+            }
+            else if (name === "deactivate") {
+                deactivate = captureImportPath(name, property.value, scope, currPath, helpers);
+            }
+        }
+        if (!id || !schema) {
+            throw new Error("Expected block to have id and schema properties");
+        }
+        result.set(id, {
+            execute,
+            schema,
+            activate,
+            deactivate,
         });
     }
-    if (!exports.value.has("schema")) {
-        return errored({ code: "MISSING_SCHEMA", path: filePath });
+}
+function findProperty(obj, name, scope) {
+    const property = obj.properties.find((property) => property.type === "Property" &&
+        property.key.type === "Identifier" &&
+        property.key.name === name);
+    if (!property) {
+        throw new Error(`Expected property ${name} to be present`);
+    }
+    let value = property.value;
+    if (value.type === "Identifier") {
+        const resolvedValue = resolveIdentifierToValue(value, scope);
+        if (resolvedValue && resolvedValue?.type !== "ImportBinding") {
+            value = resolvedValue;
+        }
+    }
+    return value;
+}
+export function findWorkflowBlockModulesFromSource(source, currPath, helpers) {
+    const result = new Map();
+    try {
+        const ast = parse(source, {
+            range: true,
+            jsx: true,
+        });
+        const scopeManager = analyze(ast, {
+            sourceType: "module",
+        });
+        const moduleScope = scopeManager.acquire(ast, true);
+        if (moduleScope === null) {
+            throw new Error("Expected to be able to acquire module scope");
+        }
+        walk(ast, null, {
+            ExportNamedDeclaration(node, context) {
+                if (!node.declaration || node.declaration.type !== "VariableDeclaration") {
+                    throw new Error("Expected export to be a variable declaration");
+                }
+                if (node.declaration.declarations.length !== 1) {
+                    throw new Error("Expected exactly one declaration per export");
+                }
+                const declaration = node.declaration.declarations[0];
+                if (declaration.id.type !== "Identifier" || declaration.id.name !== "app") {
+                    throw new Error("Expected export to be named 'app'");
+                }
+                const appValue = declaration.init;
+                if (!appValue || appValue.type !== "ObjectExpression") {
+                    throw new Error("Expected app to be initialized to an object");
+                }
+                const workflow = findProperty(appValue, "workflow", moduleScope);
+                if (workflow.type !== "ObjectExpression") {
+                    throw new Error("Expected app to have a workflow property as an object");
+                }
+                const blocks = findProperty(workflow, "blocks", moduleScope);
+                if (blocks.type !== "ObjectExpression") {
+                    throw new Error("Expected workflow to have a blocks property as an object");
+                }
+                const steps = findProperty(blocks, "steps", moduleScope);
+                if (steps.type !== "ArrayExpression") {
+                    throw new Error("Expected blocks to have a steps property as an array");
+                }
+                for (const element of steps.elements) {
+                    if (element) {
+                        visitBlock(element, moduleScope, result, currPath, helpers);
+                    }
+                }
+            },
+        });
     }
-    if (exports.value.has("execute") ||
-        exports.value.has("activate") ||
-        exports.value.has("deactivate")) {
-        return complete([{ file, path: filePath, blockId }]);
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return errored({ code: "WORKFLOW_BLOCK_RESOLUTION_FAILED", message });
     }
-    return errored({ code: "MISSING_FUNCTIONS", path: filePath });
+    return complete(result);
 }
-export async function findWorkflowBlockModules(workflowBlocksDir) {
-    const contentResult = await fromPromise(fs.readdir(workflowBlocksDir, { withFileTypes: true }));
-    if (isErrored(contentResult)) {
-        return complete([]);
+export async function findWorkflowBlockModules(srcDirAbsolute) {
+    const appEntryPoint = await getAppEntryPoint(srcDirAbsolute);
+    if (!appEntryPoint) {
+        return complete(new Map());
     }
-    const modulesResult = await combineAsync(contentResult.value.filter((item) => !item.isDirectory()).map(processFile));
-    return map(modulesResult, (modules) => modules.flat());
+    const getModuleSource = (path) => {
+        return fs.readFileSync(path, "utf-8");
+    };
+    const doesModuleExist = (path) => {
+        return fs.existsSync(path);
+    };
+    const modules = new Map();
+    return findWorkflowBlockModulesFromSource(appEntryPoint.content, appEntryPoint.path, {
+        getModuleSource,
+        doesModuleExist,
+        modules,
+    });
 }

package/lib/build/server/fine-workflow-block.test.js

@@ -0,0 +1,66 @@
+import { describe, expect, it } from "vitest";
+import { findWorkflowBlockModulesFromSource } from "./find-workflow-block-server-modules.js";
+describe("findWorkflowBlockModulesFromSource", () => {
+    it("should find workflow block modules in source code", () => {
+        const appTsSource = `
+import { block } from "./test-block"
+export const app = {
+    workflow: {
+        blocks:  {
+            steps: [block],
+        },
+    },
+}`;
+        const blockTsSource = `
+import {execute, schema} from "./test-block.block"
+export const block = {
+    id: "test-block",
+    title: "test",
+    schema,
+    execute,
+    Configurator: () => {},
+}`;
+        const blockBlockTsSource = `
+import {experimental_Workflow} from "attio/server"
+export const schema = async () => ({
+    test: experimental_Workflow.number(),
+})
+export const execute = async (config) => {}`;
+        const getModuleSource = (path) => {
+            if (path === "/test-block.ts") {
+                return blockTsSource;
+            }
+            if (path === "/test-block.block.ts") {
+                return blockBlockTsSource;
+            }
+            return "";
+        };
+        const doesModuleExist = (path) => {
+            if (path === "/test-block.ts" || path === "/test-block.block.ts") {
+                return true;
+            }
+            return false;
+        };
+        const modules = new Map();
+        const result = findWorkflowBlockModulesFromSource(appTsSource, "", {
+            modules,
+            getModuleSource,
+            doesModuleExist,
+        });
+        expect(result.state).toBe("complete");
+        if (result.state === "complete") {
+            const value = result.value;
+            const entries = value.entries();
+            expect(value.size).toBe(1);
+            expect(entries.next().value).toEqual([
+                "test-block",
+                {
+                    activate: undefined,
+                    deactivate: undefined,
+                    execute: { export: "execute", path: "/test-block.block.ts" },
+                    schema: { export: "schema", path: "/test-block.block.ts" },
+                },
+            ]);
+        }
+    });
+});