@dxos/functions 0.8.4-main.5acf9ea → 0.8.4-main.5ea62a8

package/src/testing/persist-database.test.ts

@@ -0,0 +1,87 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, expect, it } from '@effect/vitest';
+import { Effect } from 'effect';
+
+import { Filter, Obj, Query, Type } from '@dxos/echo';
+import { DataType } from '@dxos/schema';
+
+import { DatabaseService } from '../services';
+
+import { TestDatabaseLayer, testStoragePath } from './layer';
+
+describe('TestDatabaseLayer', { timeout: 600_000 }, () => {
+  it.effect(
+    'persist database to disk',
+    Effect.fnUntraced(function* ({ expect: _ }) {
+      const DbLayer = TestDatabaseLayer({
+        storagePath: testStoragePath({ name: `feed-test-${Date.now()}` }),
+      });
+
+      yield* Effect.gen(function* () {
+        yield* DatabaseService.add(Obj.make(Type.Expando, { label: 'test' }));
+        yield* DatabaseService.flush({ indexes: true });
+      }).pipe(Effect.provide(DbLayer));
+
+      yield* Effect.gen(function* () {
+        const { objects } = yield* DatabaseService.runQuery(Query.select(Filter.everything()));
+        expect(objects[0]?.label).toEqual('test');
+      }).pipe(Effect.provide(DbLayer));
+    }),
+  );
+
+  it.effect(
+    'reload database -- save index before restart',
+    Effect.fnUntraced(function* ({ expect: _ }) {
+      const NUM_OBJECTS = 500;
+      const DbLayer = TestDatabaseLayer({
+        types: [DataType.Person],
+        storagePath: testStoragePath({ name: `reload-test-${Date.now()}` }),
+      });
+
+      yield* Effect.gen(function* () {
+        for (let i = 0; i < NUM_OBJECTS; i++) {
+          yield* DatabaseService.add(Obj.make(DataType.Person, { nickname: `Person ${i}` }));
+        }
+        yield* DatabaseService.flush({ indexes: true });
+      }).pipe(Effect.provide(DbLayer));
+
+      yield* Effect.gen(function* () {
+        const { objects } = yield* DatabaseService.runQuery(Query.select(Filter.type(DataType.Person)));
+        expect(objects.length).toEqual(NUM_OBJECTS);
+      }).pipe(Effect.provide(DbLayer));
+    }),
+  );
+
+  it.effect.skip(
+    'reload database -- save index before restart [manual]',
+    Effect.fnUntraced(
+      function* ({ expect: _ }) {
+        const NUM_OBJECTS = 500;
+
+        {
+          const { objects } = yield* DatabaseService.runQuery(Query.select(Filter.type(DataType.Person)));
+          console.log({ count: objects.length });
+        }
+
+        for (let i = 0; i < NUM_OBJECTS; i++) {
+          yield* DatabaseService.add(Obj.make(DataType.Person, { nickname: `Person ${i}` }));
+        }
+        yield* DatabaseService.flush({ indexes: true });
+
+        {
+          const { objects } = yield* DatabaseService.runQuery(Query.select(Filter.type(DataType.Person)));
+          console.log({ count: objects.length });
+        }
+      },
+      Effect.provide(
+        TestDatabaseLayer({
+          types: [DataType.Person],
+          storagePath: testStoragePath({ name: `reload-test` }),
+        }),
+      ),
+    ),
+  );
+});

package/src/testing/services.ts

@@ -9,15 +9,16 @@ import type { EchoDatabase, QueueFactory } from '@dxos/echo-db';
 import { assertArgument } from '@dxos/invariant';
 
 import {
+  type ComputeEventLogger,
   ConfiguredCredentialsService,
   type CredentialsService,
   DatabaseService,
-  type ComputeEventLogger,
   QueueService,
   ServiceContainer,
   type ServiceCredential,
   type TracingService,
 } from '../services';
+
 import { consoleLogger, noopLogger } from './logger';
 
 // TODO(burdon): Factor out.

package/src/trace.ts

@@ -4,12 +4,12 @@
 
 import { Schema } from 'effect';
 
-import { Type, type Ref } from '@dxos/echo';
+import { type Ref, Type } from '@dxos/echo';
 import { Queue } from '@dxos/echo-db';
 import { ObjectId } from '@dxos/echo-schema';
 import { log } from '@dxos/log';
 
-import { FunctionTrigger, type FunctionTriggerType } from './types';
+import { FunctionTrigger } from './types';
 
 export enum InvocationOutcome {
   SUCCESS = 'success',
@@ -101,10 +101,8 @@ export const TraceEvent = Schema.Struct({
   // TODO(burdon): Need enum/numeric result (not string).
   outcome: Schema.String,
   truncated: Schema.Boolean,
-  /**
-   * Time when the event was persisted.
-   */
-  ingestionTimestampMs: Schema.Number,
+  /** Time when the event was persisted. */
+  ingestionTimestamp: Schema.Number,
   logs: Schema.Array(TraceEventLog),
   exceptions: Schema.Array(TraceEventException),
 }).pipe(Type.Obj({ typename: 'dxos.org/type/TraceEvent', version: '0.1.0' }));
@@ -123,7 +121,7 @@ export type InvocationSpan = {
   durationMs: number;
   invocationTraceQueue: Ref.Ref<Queue>;
   invocationTarget: Ref.Ref<Type.Expando>;
-  trigger?: Ref.Ref<FunctionTriggerType>;
+  trigger?: Ref.Ref<FunctionTrigger>;
   exception?: TraceEventException;
 };
 

package/src/types.ts

@@ -4,7 +4,8 @@
 
 import { Schema, SchemaAST } from 'effect';
 
-import { Expando, OptionsAnnotationId, TypedObject, Ref, RawObject } from '@dxos/echo-schema';
+import { Type } from '@dxos/echo';
+import { Expando, OptionsAnnotationId, RawObject, Ref } from '@dxos/echo-schema';
 import { DXN } from '@dxos/keys';
 
 import { FunctionType } from './schema';
@@ -14,13 +15,8 @@ import { FunctionType } from './schema';
  * Every spec has a type field of type TriggerKind that we can use to understand which type we're working with.
  * https://www.typescriptlang.org/docs/handbook/2/narrowing.html#discriminated-unions
  */
-export enum TriggerKind {
-  Timer = 'timer',
-  Webhook = 'webhook',
-  Subscription = 'subscription',
-  Email = 'email',
-  Queue = 'queue',
-}
+export const TriggerKinds = ['timer', 'webhook', 'subscription', 'email', 'queue'] as const;
+export type TriggerKind = (typeof TriggerKinds)[number];
 
 const kindLiteralAnnotations = { title: 'Kind' };
 
@@ -28,7 +24,7 @@ const kindLiteralAnnotations = { title: 'Kind' };
  * Cron timer.
  */
 const TimerTriggerSchema = Schema.Struct({
-  kind: Schema.Literal(TriggerKind.Timer).annotations(kindLiteralAnnotations),
+  kind: Schema.Literal('timer').annotations(kindLiteralAnnotations),
   cron: Schema.String.annotations({
     title: 'Cron',
     [SchemaAST.ExamplesAnnotationId]: ['0 0 * * *'],
@@ -37,12 +33,12 @@ const TimerTriggerSchema = Schema.Struct({
 export type TimerTrigger = Schema.Schema.Type<typeof TimerTriggerSchema>;
 
 const EmailTriggerSchema = Schema.Struct({
-  kind: Schema.Literal(TriggerKind.Email).annotations(kindLiteralAnnotations),
+  kind: Schema.Literal('email').annotations(kindLiteralAnnotations),
 }).pipe(Schema.mutable);
 export type EmailTrigger = Schema.Schema.Type<typeof EmailTriggerSchema>;
 
 const QueueTriggerSchema = Schema.Struct({
-  kind: Schema.Literal(TriggerKind.Queue).annotations(kindLiteralAnnotations),
+  kind: Schema.Literal('queue').annotations(kindLiteralAnnotations),
   queue: DXN.Schema,
 }).pipe(Schema.mutable);
 export type QueueTrigger = Schema.Schema.Type<typeof QueueTriggerSchema>;
@@ -51,7 +47,7 @@ export type QueueTrigger = Schema.Schema.Type<typeof QueueTriggerSchema>;
  * Webhook.
  */
 const WebhookTriggerSchema = Schema.Struct({
-  kind: Schema.Literal(TriggerKind.Webhook).annotations(kindLiteralAnnotations),
+  kind: Schema.Literal('webhook').annotations(kindLiteralAnnotations),
   method: Schema.optional(
     Schema.String.annotations({
       title: 'Method',
@@ -76,7 +72,7 @@ const QuerySchema = Schema.Struct({
  * Subscription.
  */
 const SubscriptionTriggerSchema = Schema.Struct({
-  kind: Schema.Literal(TriggerKind.Subscription).annotations(kindLiteralAnnotations),
+  kind: Schema.Literal('subscription').annotations(kindLiteralAnnotations),
   // TODO(burdon): Define query DSL (from ECHO). Reconcile with Table.Query.
   filter: QuerySchema,
   options: Schema.optional(
@@ -155,7 +151,7 @@ export type TimerTriggerOutput = Schema.Schema.Type<typeof TimerTriggerOutput>;
  * Function is invoked with the `payload` passed as input data.
  * The event that triggers the function is available in the function context.
  */
-export const FunctionTriggerSchema = Schema.Struct({
+export const FunctionTrigger = Schema.Struct({
   /**
    * Function or workflow to invoke.
    */
@@ -185,17 +181,13 @@ export const FunctionTriggerSchema = Schema.Struct({
    * }
    */
   input: Schema.optional(Schema.mutable(Schema.Record({ key: Schema.String, value: Schema.Any }))),
-});
-
-export type FunctionTriggerType = Schema.Schema.Type<typeof FunctionTriggerSchema>;
-
-/**
- * Function trigger.
- */
-export class FunctionTrigger extends TypedObject({
-  typename: 'dxos.org/type/FunctionTrigger',
-  version: '0.2.0',
-})(FunctionTriggerSchema.fields) {}
+}).pipe(
+  Type.Obj({
+    typename: 'dxos.org/type/FunctionTrigger',
+    version: '0.2.0',
+  }),
+);
+export type FunctionTrigger = Schema.Schema.Type<typeof FunctionTrigger>;
 
 // TODO(wittjosiah): Remove?
 

package/src/url.ts

@@ -6,7 +6,7 @@ import { type ObjectMeta } from '@dxos/echo-schema';
 import { type SpaceId } from '@dxos/keys';
 
 // TODO: use URL scheme for source?
-const FUNCTIONS_META_KEY = 'dxos.org/service/function';
+export const FUNCTIONS_META_KEY = 'dxos.org/service/function';
 
 export const FUNCTIONS_PRESET_META_KEY = 'dxos.org/service/function-preset';
 
@@ -14,32 +14,35 @@ const isSecure = (protocol: string) => {
   return protocol === 'https:' || protocol === 'wss:';
 };
 
-export const getUserFunctionUrlInMetadata = (meta: ObjectMeta) => {
+/**
+ * NOTE: functionId is backend ID, not ECHO object id.
+ */
+export const getUserFunctionIdInMetadata = (meta: ObjectMeta) => {
   return meta.keys.find((key) => key.source === FUNCTIONS_META_KEY)?.id;
 };
 
-export const setUserFunctionUrlInMetadata = (meta: ObjectMeta, functionUrl: string) => {
+/**
+ * NOTE: functionId is backend ID, not ECHO object id.
+ */
+export const setUserFunctionIdInMetadata = (meta: ObjectMeta, functionId: string) => {
   const key = meta.keys.find((key) => key.source === FUNCTIONS_META_KEY);
   if (key) {
-    if (key.id !== functionUrl) {
+    if (key.id !== functionId) {
       throw new Error('Metadata mismatch');
     }
   } else {
-    meta.keys.push({ source: FUNCTIONS_META_KEY, id: functionUrl });
+    meta.keys.push({ source: FUNCTIONS_META_KEY, id: functionId });
   }
 };
 
 /**
  * NOTE: functionId is backend ID, not ECHO object id.
  */
-export const makeFunctionUrl = (fn: { functionId: string }) => `/${fn.functionId}`;
-
-export const getInvocationUrl = (functionUrl: string, edgeUrl: string, options: InvocationOptions = {}) => {
+export const getInvocationUrl = (functionId: string, edgeUrl: string, options: InvocationOptions = {}) => {
   const baseUrl = new URL('functions/', edgeUrl);
 
   // Leading slashes cause the URL to be treated as an absolute path.
-  const relativeUrl = functionUrl.replace(/^\//, '');
-  const url = new URL(`./${relativeUrl}`, baseUrl.toString());
+  const url = new URL(`./${functionId}`, baseUrl.toString());
   options.spaceId && url.searchParams.set('spaceId', options.spaceId);
   options.subjectId && url.searchParams.set('subjectId', options.subjectId);
   url.protocol = isSecure(url.protocol) ? 'https' : 'http';