@dxos/edge-compute 0.0.0

package/src/native/bundler.ts

@@ -0,0 +1,231 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+/* eslint-disable no-console */
+
+import * as Array from 'effect/Array';
+import * as Function from 'effect/Function';
+import * as Order from 'effect/Order';
+import * as Record from 'effect/Record';
+import { type Message, build } from 'esbuild';
+import { statSync } from 'node:fs';
+import { writeFile } from 'node:fs/promises';
+import * as fs from 'node:fs/promises';
+import { basename, dirname, join, relative, resolve } from 'node:path';
+
+import { BaseError } from '@dxos/errors';
+import { PublicKey } from '@dxos/keys';
+import { Unit, trim } from '@dxos/util';
+
+import { httpPlugin } from '../bundler/plugins/http-plugin-esbuild';
+
+type BundleOptions = {
+  entryPoint: string;
+  verbose?: boolean;
+};
+
+export type BundleResult = {
+  entryPoint: string;
+  assets: Record<string, Uint8Array>;
+};
+
+/**
+ * Bundles a function.
+ * Pulls in node_modules and wasm files.
+ */
+export const bundleFunction = async (options: BundleOptions): Promise<BundleResult> => {
+  const outdir = `/tmp/dxos-functions-bundle-${new Date().toISOString()}-${PublicKey.random().toHex()}`;
+  const gitDir = findGitDir(dirname(options.entryPoint));
+
+  const result = await build({
+    entryPoints: {
+      // Gets mapped to `index.js` by esbuild.
+      index: 'dxos:entrypoint',
+    },
+    bundle: true,
+    format: 'esm',
+    platform: 'browser',
+    conditions: ['workerd', 'worker', 'browser'],
+    outdir,
+    metafile: true,
+    treeShaking: true,
+    sourcemap: true,
+    splitting: true,
+    logOverride: {
+      'ignored-bare-import': 'silent',
+    },
+    loader: {
+      '.wasm': 'copy',
+    },
+    external: ['node:*', 'cloudflare:workers', 'functions-service:user-script'],
+    plugins: [
+      httpPlugin,
+      {
+        name: 'entrypoint',
+        setup: (build) => {
+          build.onResolve({ filter: /^dxos:entrypoint$/ }, () => ({
+            path: 'dxos:entrypoint',
+            namespace: 'dxos:entrypoint',
+          }));
+          build.onLoad({ filter: /^dxos:entrypoint$/, namespace: 'dxos:entrypoint' }, () => ({
+            contents: trim`
+              export default {
+                fetch: async (...args) => {
+                  const { wrapFunctionHandler } = await import('@dxos/compute-runtime');
+                  const { wrapHandlerForCloudflare, setupFunctionsLogger } = await import('@dxos/functions-runtime-cloudflare');
+                  const { default: handler } = await import('${options.entryPoint}');
+
+                  setupFunctionsLogger();
+
+                  //
+                  // Wrapper to make the function cloudflare-compatible.
+                  //
+                  return wrapHandlerForCloudflare(wrapFunctionHandler(handler))(...args);
+                },
+              };
+            `,
+            resolveDir: new URL('.', import.meta.url).pathname,
+          }));
+        },
+      },
+      {
+        name: 'metafile',
+        setup: (build) => {
+          build.onEnd(async (result) => {
+            await writeFile(
+              join(build.initialOptions.outdir!, 'metafile.json'),
+              JSON.stringify(result.metafile, null, 2),
+            );
+            await writeFile(
+              join(build.initialOptions.outdir!, 'manifest.json'),
+              JSON.stringify(
+                {
+                  files: Object.keys(result.metafile!.outputs).map((path) => ({
+                    name: relative(build.initialOptions.outdir!, path),
+                  })),
+                },
+                null,
+                2,
+              ),
+            );
+          });
+        },
+      },
+    ],
+  });
+
+  if (result.errors.length > 0) {
+    throw new BundleCreationError(result.errors);
+  }
+
+  const assetPaths = Object.keys(result.metafile!.outputs).map((path) => relative(outdir, path));
+  const assets = Function.pipe(
+    await Promise.all(assetPaths.map((path) => fs.readFile(join(outdir, path)))),
+    Array.zipWith(assetPaths, (content, path) => [path, content] as const),
+    Record.fromEntries,
+  );
+
+  if (options.verbose) {
+    console.log('Function compiled');
+    console.log('Metafile path:', `${outdir}/metafile.json`);
+    console.log('Assets:\n');
+    console.log(
+      Object.entries(result.metafile!.outputs)
+        .sort((a, b) => b[1].bytes - a[1].bytes)
+        .map(
+          ([path, desc]) =>
+            `${formatBytes(desc.bytes).padEnd(10)} - ${relative(outdir, path)} ${basename(path) === 'index.js' ? ' (entry point)' : ''}`,
+        )
+        .join('\n'),
+    );
+
+    const filesInOutput = Function.pipe(
+      result.metafile.outputs,
+      Record.values,
+      Array.flatMap((_) => Record.toEntries(_.inputs)),
+    );
+
+    const moduleInOutput = Function.pipe(
+      result.metafile.inputs,
+      Record.values,
+      Array.flatMap((_) => _.imports),
+      Array.filter((_) => !!_.original?.match(/^@[a-zA-Z]+/)),
+      Array.filter((_) => !!filesInOutput.find(([name]) => name === _.path)),
+      Array.map((_) => _.original!),
+      Array.dedupe,
+      Array.sort(Order.string),
+    );
+    console.log(`Modules in output:\n${moduleInOutput.map((_) => ` - ${_}`).join('\n')}`);
+  }
+
+  for (const path of Object.keys(assets)) {
+    if (path.endsWith('.map')) {
+      const content = assets[path];
+      const map = JSON.parse(new TextDecoder().decode(content));
+      const processedMap = postprocessSourceMap(map, outdir, gitDir);
+      assets[path] = Buffer.from(JSON.stringify(processedMap));
+    }
+  }
+
+  // Must match esbuild entry point.
+  return { entryPoint: 'index.js', assets };
+};
+
+class BundleCreationError extends BaseError.extend('BundleCreationError', 'Bundle creation failed') {
+  constructor(errors: Message[]) {
+    super({ context: { errors } });
+  }
+}
+
+const formatBytes = (bytes: number) => {
+  if (bytes < Unit.Kilobyte(1).unit.quotient) {
+    return Unit.Byte(bytes).toString();
+  }
+  if (bytes < Unit.Megabyte(1).unit.quotient) {
+    return Unit.Kilobyte(bytes).toString();
+  }
+  if (bytes < Unit.Gigabyte(1).unit.quotient) {
+    return Unit.Megabyte(bytes).toString();
+  }
+  return Unit.Gigabyte(bytes).toString();
+};
+
+const findGitDir = (startPath: string): string | null => {
+  let current = startPath;
+  while (current !== '/') {
+    const gitPath = join(current, '.git');
+    try {
+      if (statSync(gitPath).isDirectory()) {
+        return gitPath;
+      }
+    } catch {
+      // ignore
+    }
+    current = dirname(current);
+  }
+  return null;
+};
+
+/**
+ * Adjust source paths to be relative to the repo root.
+ */
+const postprocessSourceMap = (map: any, outDir: string, gitDir: string | null) => {
+  if (!gitDir) {
+    return map;
+  }
+
+  // Update source paths to be relative to the output directory
+  if (map.sources && Array.isArray(map.sources)) {
+    map.sources = map.sources.map((source: string) => {
+      const resolved = resolve(outDir, source);
+      if (resolved.startsWith(dirname(gitDir))) {
+        const rel = relative(dirname(gitDir), resolved);
+        return rel;
+      }
+      return source;
+    });
+  }
+
+  return map;
+};

package/src/native/index.ts

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

package/src/testing/index.ts

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

package/src/testing/logger.ts

@@ -0,0 +1,14 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Trace } from '@dxos/compute';
+import { log } from '@dxos/log';
+
+export const noopTraceWriter: Trace.TraceWriter = Trace.noopWriter;
+
+export const consoleTraceWriter: Trace.TraceWriter = {
+  write: (event, payload) => {
+    log.info(event.key, payload as object);
+  },
+};

package/src/testing/services.ts

@@ -0,0 +1,95 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import type * as Context from 'effect/Context';
+
+import type { Space } from '@dxos/client/echo';
+import { type Credential, type Trace } from '@dxos/compute';
+import { ConfiguredCredentialsService } from '@dxos/compute-runtime';
+import { ServiceContainer } from '@dxos/compute-runtime';
+import { Database } from '@dxos/echo';
+import { type EchoDatabase } from '@dxos/echo-client';
+import { assertArgument } from '@dxos/invariant';
+
+import { consoleTraceWriter, noopTraceWriter } from './logger';
+
+// TODO(burdon): Factor out.
+export type OneOf<T> = {
+  [K in keyof T]: { [P in K]: T[P] } & { [P in Exclude<keyof T, K>]?: never };
+}[keyof T];
+
+export type AiServiceProvider = 'dev' | 'edge' | 'ollama' | 'lmstudio';
+
+export type TestServiceOptions = {
+  /**
+   * AI service configuration.
+   */
+  ai?: any;
+
+  /**
+   * Credentials service configuration.
+   */
+  credentials?: OneOf<{
+    /**
+     * Predefined credentials list.
+     */
+    services?: Credential.ServiceCredential[];
+
+    /**
+     * Custom credentials service.
+     */
+    service?: Context.Tag.Service<Credential.CredentialsService>;
+  }>;
+
+  /**
+   * Database configuration.
+   */
+  db?: EchoDatabase;
+
+  /**
+   * Gets database service from the space.
+   * Exclusive with: `db`
+   */
+  space?: Space;
+
+  /**
+   * Trace writer configuration.
+   */
+  logging?: {
+    enabled?: boolean;
+    trace?: Context.Tag.Service<Trace.TraceService>;
+  };
+};
+
+/**
+ * @deprecated
+ */
+export const createTestServices = ({
+  ai,
+  credentials,
+  db,
+  logging,
+  space,
+}: TestServiceOptions = {}): ServiceContainer => {
+  assertArgument(!(!!space && !!db), 'space', 'space can be provided only if db is not');
+
+  return new ServiceContainer().setServices({
+    // ai: createAiService(ai),
+    credentials: createCredentialsService(credentials),
+    database: space || db ? Database.makeService(space?.db || db!) : undefined,
+    trace: logging?.trace ?? (logging?.enabled ? consoleTraceWriter : noopTraceWriter),
+  });
+};
+
+const createCredentialsService = (
+  credentials: TestServiceOptions['credentials'] | undefined,
+): Context.Tag.Service<Credential.CredentialsService> | undefined => {
+  if (credentials?.services) {
+    return new ConfiguredCredentialsService(credentials.services);
+  }
+
+  if (credentials?.service) {
+    return credentials.service;
+  }
+};