@dxos/functions 0.8.4-main.84f28bd → 0.8.4-main.8baae0fced

package/src/bundler/bundler.ts

@@ -1,292 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import { FetchHttpClient, HttpClient } from '@effect/platform';
-import { Duration, Effect, pipe, Schedule } from 'effect';
-import { type BuildOptions, type Loader, build, initialize, type BuildResult, type Plugin } from 'esbuild-wasm';
-
-import { subtleCrypto } from '@dxos/crypto';
-import { runAndForwardErrors } from '@dxos/effect';
-import { invariant } from '@dxos/invariant';
-import { log } from '@dxos/log';
-
-export type Import = {
-  moduleUrl: string;
-  defaultImport: boolean;
-  namedImports: string[];
-};
-
-export type BundleOptions = {
-  /**
-   * Path to the source file on the local file system.
-   * If provided, the path will be used instead of the `source` code.
-   */
-  path?: string;
-
-  /**
-   * Source code to bundle.
-   * Required if `path` is not provided.
-   */
-  source?: string;
-};
-
-export type BundleResult = {
-  timestamp: number;
-  sourceHash?: Buffer;
-  imports?: Import[];
-  bundle?: string;
-  error?: any;
-};
-
-export type BundlerOptions = {
-  platform: BuildOptions['platform'];
-  sandboxedModules: string[];
-  remoteModules: Record<string, string>;
-};
-
-let initialized: Promise<void>;
-export const initializeBundler = async (options: { wasmUrl: string }) => {
-  await (initialized ??= initialize({
-    wasmURL: options.wasmUrl,
-  }));
-};
-
-/**
- * ESBuild bundler.
- */
-export class Bundler {
-  constructor(private readonly _options: BundlerOptions) {}
-
-  async bundle({ path, source }: BundleOptions): Promise<BundleResult> {
-    const { sandboxedModules: providedModules, ...options } = this._options;
-
-    const createResult = async (result?: Partial<BundleResult>) => {
-      return {
-        timestamp: Date.now(),
-        sourceHash: source ? Buffer.from(await subtleCrypto.digest('SHA-256', Buffer.from(source))) : undefined,
-        ...result,
-      };
-    };
-
-    if (this._options.platform === 'browser') {
-      invariant(initialized, 'Compiler not initialized.');
-      await initialized;
-    }
-
-    const imports = source ? analyzeSourceFileImports(source) : [];
-
-    // https://esbuild.github.io/api/#build
-    try {
-      const result = await build({
-        platform: options.platform,
-        conditions: ['workerd', 'browser'],
-        metafile: true,
-        write: false,
-        entryPoints: [path ?? 'memory:main.tsx'],
-        bundle: true,
-        format: 'esm',
-        plugins: [
-          {
-            name: 'memory',
-            setup: (build) => {
-              build.onResolve({ filter: /^\.\/runtime\.js$/ }, ({ path }) => {
-                return { path, external: true };
-              });
-
-              build.onResolve({ filter: /^dxos:functions$/ }, ({ path }) => {
-                return { path: './runtime.js', external: true };
-              });
-
-              build.onResolve({ filter: /^memory:/ }, ({ path }) => {
-                return { path: path.split(':')[1], namespace: 'memory' };
-              });
-
-              build.onLoad({ filter: /.*/, namespace: 'memory' }, ({ path }) => {
-                if (path === 'main.tsx') {
-                  return {
-                    contents: source,
-                    loader: 'tsx',
-                  };
-                }
-              });
-
-              for (const module of providedModules) {
-                build.onResolve({ filter: new RegExp(`^${module}$`) }, ({ path }) => {
-                  return { path, namespace: 'injected-module' };
-                });
-              }
-
-              build.onLoad({ filter: /.*/, namespace: 'injected-module' }, ({ path }) => {
-                const namedImports = imports.find((entry) => entry.moduleIdentifier === path)?.namedImports ?? [];
-                return {
-                  contents: `
-                  const { ${namedImports.join(',')} } = window.__DXOS_SANDBOX_MODULES__[${JSON.stringify(path)}];
-                  export { ${namedImports.join(',')} };
-                  export default window.__DXOS_SANDBOX_MODULES__[${JSON.stringify(path)}].default;
-                `,
-                  loader: 'tsx',
-                };
-              });
-            },
-          },
-          httpPlugin,
-        ],
-      });
-
-      log('compile complete', result.metafile);
-
-      return await createResult({
-        imports: this.analyzeImports(result),
-        bundle: result.outputFiles![0].text,
-      });
-    } catch (err) {
-      return await createResult({ error: err });
-    }
-  }
-
-  // TODO(dmaretskyi): In the future we can replace the compiler with SWC with plugins running in WASM.
-  analyzeImports(result: BuildResult): Import[] {
-    invariant(result.outputFiles);
-
-    // TODO(dmaretskyi): Support import aliases and wildcard imports.
-    const parsedImports = allMatches(IMPORT_REGEX, result.outputFiles[0].text);
-    return Object.values(result.metafile!.outputs)[0].imports.map((entry): Import => {
-      const namedImports: string[] = [];
-
-      const parsedImport = parsedImports.find((capture) => capture?.[4] === entry.path);
-      if (parsedImport?.[2]) {
-        NAMED_IMPORTS_REGEX.lastIndex = 0;
-        const namedImportsMatch = NAMED_IMPORTS_REGEX.exec(parsedImport[2]);
-        if (namedImportsMatch) {
-          namedImportsMatch[1].split(',').forEach((importName) => {
-            namedImports.push(importName.trim());
-          });
-        }
-      }
-
-      return {
-        moduleUrl: entry.path,
-        defaultImport: !!parsedImport?.[1],
-        namedImports,
-      };
-    });
-  }
-
-  analyzeSourceFileImports(code: string): {
-    defaultImportName: string;
-    namedImports: string[];
-    wildcardImportName: string;
-    moduleIdentifier: string;
-    quotes: string;
-  }[] {
-    // TODO(dmaretskyi): Support import aliases and wildcard imports.
-    const parsedImports = allMatches(IMPORT_REGEX, code);
-    return parsedImports.map((capture) => {
-      return {
-        defaultImportName: capture[1],
-        namedImports: capture[2]?.split(',').map((importName) => importName.trim()),
-        wildcardImportName: capture[3],
-        moduleIdentifier: capture[4],
-        quotes: capture[5],
-      };
-    });
-  }
-}
-
-// https://regex101.com/r/FEN5ks/1
-// https://stackoverflow.com/a/73265022
-// $1 = default import name (can be non-existent)
-// $2 = destructured exports (can be non-existent)
-// $3 = wildcard import name (can be non-existent)
-// $4 = module identifier
-// $5 = quotes used (either ' or ")
-const IMPORT_REGEX =
-  /import(?:(?:(?:[ \n\t]+([^ *\n\t{},]+)[ \n\t]*(?:,|[ \n\t]+))?([ \n\t]*{(?:[ \n\t]*[^ \n\t"'{}]+[ \n\t]*,?)+})?[ \n\t]*)|[ \n\t]*\*[ \n\t]*as[ \n\t]+([^ \n\t{}]+)[ \n\t]+)from[ \n\t]*(?:['"])([^'"\n]+)(['"])/gm;
-
-const NAMED_IMPORTS_REGEX = /[ \n\t]*{((?:[ \n\t]*[^ \n\t"'{}]+[ \n\t]*,?)+)}[ \n\t]*/gm;
-
-const allMatches = (regex: RegExp, str: string) => {
-  regex.lastIndex = 0;
-
-  let match;
-  const matches = [];
-  while ((match = regex.exec(str))) {
-    matches.push(match);
-  }
-
-  return matches;
-};
-
-type ParsedImport = {
-  defaultImportName?: string;
-  namedImports: string[];
-  wildcardImportName?: string;
-  moduleIdentifier: string;
-  quotes: string;
-};
-
-const analyzeSourceFileImports = (code: string): ParsedImport[] => {
-  // TODO(dmaretskyi): Support import aliases and wildcard imports.
-  const parsedImports = allMatches(IMPORT_REGEX, code);
-  return parsedImports.map((capture) => {
-    return {
-      defaultImportName: capture[1],
-      namedImports: capture[2]
-        ?.trim()
-        .slice(1, -1)
-        .split(',')
-        .map((importName) => importName.trim()),
-      wildcardImportName: capture[3],
-      moduleIdentifier: capture[4],
-      quotes: capture[5],
-    };
-  });
-};
-
-const MAX_RETRIES = 5;
-const INITIAL_DELAY = 1_000;
-
-const httpPlugin: Plugin = {
-  name: 'http',
-  setup: (build) => {
-    // Intercept import paths starting with "http:" and "https:" so esbuild doesn't attempt to map them to a file system location.
-    // Tag them with the "http-url" namespace to associate them with this plugin.
-    build.onResolve({ filter: /^https?:\/\// }, (args) => ({
-      path: args.path,
-      namespace: 'http-url',
-    }));
-
-    // We also want to intercept all import paths inside downloaded files and resolve them against the original URL.
-    // All of these files will be in the "http-url" namespace.
-    // Make sure to keep the newly resolved URL in the "http-url" namespace so imports inside it will also be resolved as URLs recursively.
-    build.onResolve({ filter: /.*/, namespace: 'http-url' }, (args) => ({
-      path: new URL(args.path, args.importer).toString(),
-      namespace: 'http-url',
-    }));
-
-    // When a URL is loaded, we want to actually download the content from the internet.
-    // This has just enough logic to be able to handle the example import from unpkg.com but in reality this would probably need to be more complex.
-    build.onLoad({ filter: /.*/, namespace: 'http-url' }, async (args) => {
-      return Effect.gen(function* () {
-        const response = yield* HttpClient.get(args.path);
-        if (response.status !== 200) {
-          throw new Error(`failed to fetch: ${response.status}`);
-        }
-
-        const text = yield* response.text;
-        return { contents: text, loader: 'jsx' as Loader };
-      }).pipe(
-        Effect.retry(
-          pipe(
-            Schedule.exponential(Duration.millis(INITIAL_DELAY)),
-            Schedule.jittered,
-            Schedule.intersect(Schedule.recurs(MAX_RETRIES - 1)),
-          ),
-        ),
-        Effect.provide(FetchHttpClient.layer),
-        runAndForwardErrors,
-      );
-    });
-  },
-};

package/src/bundler/index.ts

@@ -1,5 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-export * from './bundler';

package/src/edge/functions.ts

@@ -1,64 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { type DID } from 'iso-did/types';
-
-import { type Client } from '@dxos/client';
-import { createEdgeIdentity } from '@dxos/client/edge';
-import { EdgeHttpClient } from '@dxos/edge-client';
-import { invariant } from '@dxos/invariant';
-import type { PublicKey } from '@dxos/keys';
-import { log } from '@dxos/log';
-import { type UploadFunctionResponseBody } from '@dxos/protocols';
-
-export type UploadWorkerArgs = {
-  client: Client;
-  source: string;
-  version: string;
-  name?: string;
-  functionId?: string;
-  ownerPublicKey: PublicKey;
-};
-
-export const uploadWorkerFunction = async ({
-  client,
-  version,
-  source,
-  name,
-  functionId,
-  ownerPublicKey,
-}: UploadWorkerArgs): Promise<UploadFunctionResponseBody> => {
-  const edgeUrl = client.config.values.runtime?.services?.edge?.url;
-  invariant(edgeUrl, 'Edge is not configured.');
-  const edgeClient = new EdgeHttpClient(edgeUrl);
-  const edgeIdentity = createEdgeIdentity(client);
-  edgeClient.setIdentity(edgeIdentity);
-  const response = await edgeClient.uploadFunction(
-    { functionId },
-    { name, version, script: source, ownerPublicKey: ownerPublicKey.toHex() },
-  );
-
-  // TODO(burdon): Edge service log.
-  log.info('Uploaded', {
-    identityKey: edgeIdentity.identityKey,
-    functionId,
-    name,
-    source: source.length,
-    response,
-  });
-
-  return response;
-};
-
-export const incrementSemverPatch = (version: string): string => {
-  const [major, minor, patch] = version.split('.');
-  const patchNum = Number(patch);
-  invariant(!Number.isNaN(patchNum), `Unexpected function version format: ${version}`);
-  return [major, minor, String(patchNum + 1)].join('.');
-};
-
-// TODO(burdon): Factor out.
-export const publicKeyToDid = (key: PublicKey): DID => {
-  return `did:key:${key.toHex()}`;
-};

package/src/edge/index.ts

@@ -1,9 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-// NOTE: This module is separate because it uses the edge client.
-//  This means it cannot be used on edge itself.
-// TODO(wittjosiah): Factor out.
-
-export * from './functions';

package/src/executor/executor.ts

@@ -1,54 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Effect, Schema } from 'effect';
-
-import type { SpaceId } from '@dxos/client/echo';
-import { runAndForwardErrors } from '@dxos/effect';
-
-import type { FunctionContext, FunctionDefinition } from '../handler';
-import type { ServiceContainer, Services } from '../services';
-
-export class FunctionExecutor {
-  constructor(private readonly _services: ServiceContainer) {}
-
-  // TODO(dmaretskyi): Invocation context: queue, space, etc...
-  async invoke<F extends FunctionDefinition<any, any>>(
-    fnDef: F,
-    input: F extends FunctionDefinition<infer I, infer _O> ? I : never,
-  ): Promise<F extends FunctionDefinition<infer _I, infer O> ? O : never> {
-    // Assert input matches schema
-    const assertInput = fnDef.inputSchema.pipe(Schema.asserts);
-    (assertInput as any)(input);
-
-    const context: FunctionContext = {
-      getService: this._services.getService.bind(this._services),
-      getSpace: async (_spaceId: SpaceId) => {
-        throw new Error('Not available. Use the database service instead.');
-      },
-      space: undefined,
-      get ai(): never {
-        throw new Error('Not available. Use the ai service instead.');
-      },
-    };
-
-    const result = fnDef.handler({ context, data: input });
-
-    let data: unknown;
-    if (Effect.isEffect(result)) {
-      data = await (result as Effect.Effect<unknown, unknown, Services>).pipe(
-        Effect.provide(this._services.createLayer()),
-        runAndForwardErrors,
-      );
-    } else {
-      data = await result;
-    }
-
-    // Assert output matches schema
-    const assertOutput = fnDef.outputSchema?.pipe(Schema.asserts);
-    (assertOutput as any)(data);
-
-    return data as any;
-  }
-}

package/src/handler.ts

@@ -1,113 +0,0 @@
-//
-// Copyright 2023 DXOS.org
-//
-
-import { Schema, type Context, type Effect } from 'effect';
-
-import { type AiServiceClient } from '@dxos/ai';
-// import { type Space } from '@dxos/client/echo';
-import type { EchoDatabase } from '@dxos/echo-db';
-import { type HasId } from '@dxos/echo-schema';
-import { type SpaceId, type DXN } from '@dxos/keys';
-import { type QueryResult } from '@dxos/protocols';
-
-import type { Services } from './services';
-
-// TODO(burdon): Model after http request. Ref Lambda/OpenFaaS.
-// https://docs.aws.amazon.com/lambda/latest/dg/typescript-handler.html
-// https://www.serverless.com/framework/docs/providers/aws/guide/serverless.yml/#functions
-// https://www.npmjs.com/package/aws-lambda
-
-/**
- * Function handler.
- */
-export type FunctionHandler<TData = {}, TOutput = any> = (params: {
-  /**
-   * Services and context available to the function.
-   */
-  context: FunctionContext;
-
-  /**
-   * Data passed as the input to the function.
-   * Must match the function's input schema.
-   * This will be the payload from the trigger or other data passed into the function in a workflow.
-   */
-  data: TData;
-}) => TOutput | Promise<TOutput> | Effect.Effect<TOutput, any, Services>;
-
-/**
- * Function context.
- */
-export interface FunctionContext {
-  /**
-   * Resolves a service available to the function.
-   * @throws if the service is not available.
-   */
-  getService: <T extends Context.Tag<any, any>>(tag: T) => Context.Tag.Service<T>;
-
-  getSpace: (spaceId: SpaceId) => Promise<SpaceAPI>;
-
-  /**
-   * Space from which the function was invoked.
-   */
-  space: SpaceAPI | undefined;
-
-  ai: AiServiceClient;
-}
-
-export interface FunctionContextAi {
-  // TODO(dmaretskyi): Refer to cloudflare AI docs for more comprehensive typedefs.
-  run(model: string, inputs: any, options?: any): Promise<any>;
-}
-
-//
-// API.
-//
-
-// TODO(dmaretskyi): Temporary API to get the queues working.
-// TODO(dmaretskyi): To be replaced with integrating queues into echo.
-export interface QueuesAPI {
-  queryQueue(queue: DXN, options?: {}): Promise<QueryResult>;
-  insertIntoQueue(queue: DXN, objects: HasId[]): Promise<void>;
-}
-
-/**
- * Space interface available to functions.
- */
-export interface SpaceAPI {
-  get id(): SpaceId;
-
-  get db(): EchoDatabase;
-
-  // TODO(dmaretskyi): Align with echo api --- queues.get(id).append(items);
-  get queues(): QueuesAPI;
-}
-
-// TODO(wittjosiah): Queues are incompatible.
-const __assertFunctionSpaceIsCompatibleWithTheClientSpace = () => {
-  // const _: SpaceAPI = {} as Space;
-};
-
-export type FunctionDefinition<T = {}, O = any> = {
-  description?: string;
-  inputSchema: Schema.Schema<T, any>;
-  outputSchema?: Schema.Schema<O, any>;
-  handler: FunctionHandler<T, O>;
-};
-
-// TODO(dmaretskyi): Bind input type to function handler.
-export const defineFunction = <T, O>(params: FunctionDefinition<T, O>): FunctionDefinition<T, O> => {
-  if (!Schema.isSchema(params.inputSchema)) {
-    throw new Error('Input schema must be a valid schema');
-  }
-  if (typeof params.handler !== 'function') {
-    throw new Error('Handler must be a function');
-  }
-
-  return {
-    description: params.description,
-    inputSchema: params.inputSchema,
-    outputSchema: params.outputSchema ?? Schema.Any,
-    handler: params.handler,
-  };
-};

package/src/schema.ts

@@ -1,57 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { Schema } from 'effect';
-
-import { Type } from '@dxos/echo';
-import { JsonSchemaType, LabelAnnotation, Ref } from '@dxos/echo-schema';
-import { DataType } from '@dxos/schema';
-
-/**
- * Source script.
- */
-export const ScriptType = Schema.Struct({
-  name: Schema.optional(Schema.String),
-  description: Schema.optional(Schema.String),
-  // TODO(burdon): Change to hash of deployed content.
-  // Whether source has changed since last deploy.
-  changed: Schema.optional(Schema.Boolean),
-  source: Ref(DataType.Text),
-}).pipe(
-  Type.Obj({
-    typename: 'dxos.org/type/Script',
-    version: '0.1.0',
-  }),
-  LabelAnnotation.set(['name']),
-);
-
-export interface ScriptType extends Schema.Schema.Type<typeof ScriptType> {}
-
-/**
- * Function deployment.
- */
-export const FunctionType = Schema.Struct({
-  // TODO(burdon): Rename to id/uri?
-  name: Schema.NonEmptyString,
-  version: Schema.String,
-
-  description: Schema.optional(Schema.String),
-
-  // Reference to a source script if it exists within ECHO.
-  // TODO(burdon): Don't ref ScriptType directly (core).
-  source: Schema.optional(Ref(ScriptType)),
-
-  inputSchema: Schema.optional(JsonSchemaType),
-  outputSchema: Schema.optional(JsonSchemaType),
-
-  // Local binding to a function name.
-  binding: Schema.optional(Schema.String),
-}).pipe(
-  Type.Obj({
-    typename: 'dxos.org/type/Function',
-    version: '0.1.0',
-  }),
-  LabelAnnotation.set(['name']),
-);
-export interface FunctionType extends Schema.Schema.Type<typeof FunctionType> {}

package/src/services/ai.ts

@@ -1,32 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Context, Layer } from 'effect';
-
-import type { AiServiceClient } from '@dxos/ai';
-
-// TODO(burdon): Move to @dxos/ai.
-export class AiService extends Context.Tag('AiService')<
-  AiService,
-  {
-    readonly client: AiServiceClient;
-  }
->() {
-  static make = (client: AiServiceClient): Context.Tag.Service<AiService> => {
-    return {
-      get client() {
-        return client;
-      },
-    };
-  };
-
-  static makeLayer = (client: AiServiceClient): Layer.Layer<AiService> =>
-    Layer.succeed(AiService, AiService.make(client));
-
-  static notAvailable = Layer.succeed(AiService, {
-    get client(): AiServiceClient {
-      throw new Error('AiService not available');
-    },
-  });
-}

package/src/services/database.ts

@@ -1,50 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Context, Effect, Layer } from 'effect';
-
-import type { Obj, Ref, Relation } from '@dxos/echo';
-import type { EchoDatabase } from '@dxos/echo-db';
-import type { DXN } from '@dxos/keys';
-
-export class DatabaseService extends Context.Tag('DatabaseService')<
-  DatabaseService,
-  {
-    readonly db: EchoDatabase;
-  }
->() {
-  static notAvailable = Layer.succeed(DatabaseService, {
-    get db(): EchoDatabase {
-      throw new Error('Database not available');
-    },
-  });
-
-  static make = (db: EchoDatabase): Context.Tag.Service<DatabaseService> => {
-    return {
-      get db() {
-        return db;
-      },
-    };
-  };
-
-  static resolve: (dxn: DXN) => Effect.Effect<Obj.Any | Relation.Any, Error, DatabaseService> = Effect.fn(
-    function* (dxn) {
-      const { db } = yield* DatabaseService;
-      return yield* Effect.tryPromise({
-        try: () =>
-          db.graph.createRefResolver({ context: { space: db.spaceId } }).resolve(dxn) as Promise<
-            Obj.Any | Relation.Any
-          >,
-        catch: (error) => error as Error,
-      });
-    },
-  );
-
-  static loadRef: <T>(ref: Ref.Ref<T>) => Effect.Effect<T, Error, never> = Effect.fn(function* (ref) {
-    return yield* Effect.tryPromise({
-      try: () => ref.load(),
-      catch: (error) => error as Error,
-    });
-  });
-}