@dxos/plugin-markdown 0.8.4-main.406dc2a → 0.8.4-main.52d7546f51

package/src/blueprints/functions/create.test.ts

@@ -0,0 +1,92 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, expect, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+
+import { MemoizedAiService } from '@dxos/ai/testing';
+import { AiContextService, AiConversationService } from '@dxos/assistant';
+import { AssistantTestLayer } from '@dxos/assistant/testing';
+import { Blueprint } from '@dxos/blueprints';
+import { SpaceProperties } from '@dxos/client-protocol';
+import { DXN, Database, Obj, Query, Ref } from '@dxos/echo';
+import { TestHelpers } from '@dxos/effect/testing';
+import { FunctionInvocationService } from '@dxos/functions';
+import { invariant } from '@dxos/invariant';
+import { ObjectId } from '@dxos/keys';
+import { Markdown } from '@dxos/plugin-markdown/types';
+import { Collection } from '@dxos/schema';
+import { HasSubject } from '@dxos/types';
+
+import { WithProperties } from '../../testing';
+import * as MarkdownBlueprint from '../markdown-blueprint';
+
+import create from './create';
+
+ObjectId.dangerouslyDisableRandomness();
+
+const TestLayer = AssistantTestLayer({
+  functions: [...MarkdownBlueprint.functions],
+  types: [SpaceProperties, Collection.Collection, Blueprint.Blueprint, Markdown.Document, HasSubject.HasSubject],
+  tracing: 'pretty',
+});
+
+describe('create', () => {
+  it.effect(
+    'call a function to create a markdown document',
+    Effect.fnUntraced(
+      function* (_) {
+        const name = 'BlueYard';
+        const content = 'Founders and portfolio of BlueYard.';
+        const result = yield* FunctionInvocationService.invokeFunction(create, {
+          name,
+          content,
+        });
+
+        const doc = yield* Database.resolve(DXN.parse(result.id), Markdown.Document);
+        expect(doc.name).toBe(name);
+        const text = yield* Database.load(doc.content);
+        expect(text.content).toBe(content);
+      },
+      WithProperties,
+      Effect.provide(TestLayer),
+      TestHelpers.provideTestContext,
+    ),
+  );
+
+  it.scoped(
+    'create a markdown document',
+    Effect.fnUntraced(
+      function* (_) {
+        const markdownBlueprint = yield* Database.add(Obj.clone(MarkdownBlueprint.make()));
+        yield* AiContextService.bindContext({
+          blueprints: [Ref.make(markdownBlueprint)],
+        });
+
+        yield* AiConversationService.run({
+          prompt: `Create a document with a cookie recipe.`,
+        });
+
+        {
+          const docs = yield* Database.runQuery(Query.type(Markdown.Document));
+          if (docs.length !== 1) {
+            throw new Error(`Expected 1 document; got ${docs.length}: ${docs.map((_) => _.name)}`);
+          }
+
+          const doc = docs[0];
+          invariant(Obj.instanceOf(Markdown.Document, doc));
+          console.log({
+            name: doc.name,
+            content: yield* Database.load(doc.content).pipe(Effect.map((_) => _.content)),
+          });
+        }
+      },
+      WithProperties,
+      Effect.provide(AiConversationService.layerNewQueue().pipe(Layer.provideMerge(TestLayer))),
+      TestHelpers.provideTestContext,
+    ),
+    MemoizedAiService.isGenerationEnabled() ? 240_000 : 30_000,
+  );
+});

package/src/blueprints/functions/create.ts

@@ -0,0 +1,35 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Schema from 'effect/Schema';
+
+import { Obj } from '@dxos/echo';
+import { defineFunction } from '@dxos/functions';
+import { Collection } from '@dxos/schema';
+
+import { Markdown } from '../../types';
+
+export default defineFunction({
+  key: 'dxos.org/function/markdown/create',
+  name: 'Create',
+  description: 'Creates a new markdown document and adds it to the space.',
+  inputSchema: Schema.Struct({
+    name: Schema.String,
+    content: Schema.String,
+  }),
+  outputSchema: Schema.Struct({
+    id: Schema.String.annotations({
+      description: 'The DXN of the created document.',
+    }),
+  }),
+  handler: Effect.fn(function* ({ data: { name, content } }) {
+    const object = Markdown.make({ name, content });
+    yield* Collection.add({ object });
+
+    return {
+      id: Obj.getDXN(object).toString(),
+    };
+  }),
+});

package/src/blueprints/functions/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export { default as create } from './create';
+export { default as open } from './open';
+export { default as update } from './update';

package/src/{functions → blueprints/functions}/open.ts

@@ -5,28 +5,29 @@
 import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 
-import { ArtifactId } from '@dxos/assistant';
-import { DatabaseService, defineFunction } from '@dxos/functions';
+import { Database, Type } from '@dxos/echo';
+import { defineFunction } from '@dxos/functions';
 
-import { Markdown } from '../types';
+import { Markdown } from '../../types';
 
 export default defineFunction({
   key: 'dxos.org/function/markdown/open',
   name: 'Open',
   description: 'Opens and reads the contents of a new markdown document.',
   inputSchema: Schema.Struct({
-    id: ArtifactId.annotations({
+    doc: Type.Ref(Markdown.Document).annotations({
       description: 'The ID of the markdown document.',
     }),
   }),
   outputSchema: Schema.Struct({
     content: Schema.String,
   }),
-  handler: Effect.fn(function* ({ data: { id } }) {
-    const object = yield* DatabaseService.resolve(ArtifactId.toDXN(id), Markdown.Document);
-    const { content } = yield* Effect.promise(() => object.content.load());
-    return {
-      content,
-    };
+  handler: Effect.fn(function* ({ data: { doc } }) {
+    const { content } = yield* doc.pipe(
+      Database.load,
+      Effect.map((_) => _.content),
+      Effect.flatMap(Database.load),
+    );
+    return { content };
   }),
 });