@dxos/plugin-script 0.8.2-main.fbd8ed0 → 0.8.2-staging.7ac8446

package/src/hooks/template.ts

@@ -2,7 +2,9 @@
 // Copyright 2025 DXOS.org
 //
 
-import { FUNCTIONS_PRESET_META_KEY, type ScriptType } from '@dxos/functions';
+import { useCallback } from 'react';
+
+import { FUNCTIONS_PRESET_META_KEY, type ScriptType } from '@dxos/functions/types';
 import { getMeta } from '@dxos/live-object';
 import { createMenuItemGroup, createMenuAction } from '@dxos/react-ui-menu';
 
@@ -18,34 +20,19 @@ const createTemplateSelectGroup = () => {
   });
 };
 
-const createTemplateSelectActions = (script: ScriptType) => {
+const createTemplateSelectActions = () => {
   return templates.map((template) => {
-    return createMenuAction<TemplateActionProperties>(
-      `template--${template.id}`,
-      () => {
-        script.name = template.name;
-        script.source!.target!.content = template.source;
-        const metaKeys = getMeta(script).keys;
-        const oldPresetIndex = metaKeys.findIndex((key) => key.source === FUNCTIONS_PRESET_META_KEY);
-        if (oldPresetIndex >= 0) {
-          metaKeys.splice(oldPresetIndex, 1);
-        }
-        if (template.presetId) {
-          metaKeys.push({ source: FUNCTIONS_PRESET_META_KEY, id: template.presetId });
-        }
-      },
-      {
-        label: template.name,
-        value: template.id,
-        type: 'template',
-      },
-    );
+    return createMenuAction<TemplateActionProperties>(`template--${template.id}`, {
+      label: template.name,
+      value: template.id,
+      type: 'template',
+    });
   });
 };
 
-export const createTemplateSelect = (script: ScriptType) => {
+export const createTemplateSelect = () => {
   const templateSelectGroup = createTemplateSelectGroup();
-  const templateSelectActions = createTemplateSelectActions(script);
+  const templateSelectActions = createTemplateSelectActions();
   return {
     nodes: [templateSelectGroup, ...templateSelectActions],
     edges: [
@@ -54,3 +41,24 @@ export const createTemplateSelect = (script: ScriptType) => {
     ],
   };
 };
+
+export const useTemplateSelectHandler = ({ script }: { script: ScriptType }) => {
+  return useCallback(
+    (templateId: string) => {
+      const template = templates.find((template) => template.id === templateId);
+      if (template) {
+        script.name = template.name;
+        script.source!.target!.content = template.source;
+        const metaKeys = getMeta(script).keys;
+        const oldPresetIndex = metaKeys.findIndex((key) => key.source === FUNCTIONS_PRESET_META_KEY);
+        if (oldPresetIndex >= 0) {
+          metaKeys.splice(oldPresetIndex, 1);
+        }
+        if (template.presetId) {
+          metaKeys.push({ source: FUNCTIONS_PRESET_META_KEY, id: template.presetId });
+        }
+      }
+    },
+    [script],
+  );
+};

package/src/hooks/useToolbarAction.ts

@@ -0,0 +1,50 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useCallback } from 'react';
+
+import { type ScriptType } from '@dxos/functions/types';
+import { log } from '@dxos/log';
+import { type MenuAction, type MenuActionHandler } from '@dxos/react-ui-menu';
+
+import { type DeployActionProperties, useDeployHandler, useCopyHandler } from './deploy';
+import { type FormatActionProperties, useFormatHandler } from './format';
+import { type TemplateActionProperties, useTemplateSelectHandler } from './template';
+import { type ScriptToolbarState } from './useToolbarState';
+
+export type ScriptToolbarActionProperties = TemplateActionProperties | FormatActionProperties | DeployActionProperties;
+
+export type ScriptToolbarAction = MenuAction<ScriptToolbarActionProperties>;
+
+export const useToolbarAction = (props: {
+  state: ScriptToolbarState;
+  script: ScriptType;
+}): MenuActionHandler<ScriptToolbarAction> => {
+  const handleTemplateSelect = useTemplateSelectHandler(props);
+  const handleFormat = useFormatHandler(props);
+  const handleDeploy = useDeployHandler(props);
+  const handleCopy = useCopyHandler(props);
+
+  return useCallback<MenuActionHandler<ScriptToolbarAction>>(
+    (action: ScriptToolbarAction) => {
+      switch (action.properties.type) {
+        case 'template':
+          handleTemplateSelect(action.properties.value);
+          break;
+        case 'format':
+          void handleFormat();
+          break;
+        case 'deploy':
+          void handleDeploy();
+          break;
+        case 'copy':
+          void handleCopy();
+          break;
+        default:
+          log.error('Unknown action type', action);
+      }
+    },
+    [handleTemplateSelect, handleFormat, handleDeploy, handleCopy],
+  );
+};

package/src/hooks/useToolbarState.ts

@@ -4,7 +4,7 @@
 
 import { useMemo } from 'react';
 
-import { live } from '@dxos/live-object';
+import { create } from '@dxos/live-object';
 
 import { type DeployState } from './deploy';
 
@@ -12,5 +12,5 @@ export type ScriptToolbarState = Partial<DeployState>;
 
 // TODO(burdon): Replace with context provider?
 export const useToolbarState = (initialState: ScriptToolbarState = {}) => {
-  return useMemo(() => live<ScriptToolbarState>(initialState), []);
+  return useMemo(() => create<ScriptToolbarState>(initialState), []);
 };

package/src/meta.ts

@@ -19,6 +19,5 @@ export const meta: PluginMeta = {
 
 // TODO(ZaymonFC): Configure by scopes?
 export const defaultScriptsForIntegration: Record<string, string[]> = {
-  // TODO(wittjosiah): Also include content extraction scripts in the default set.
   'gmail.com': ['dxos.org/script/gmail'],
 };

package/src/templates/chat.ts

@@ -8,10 +8,16 @@ import { transformServerSentEvents } from 'https://esm.sh/@dxos/script-toolbox';
 /**
  * Chatbot that answers questions based on the context data.
  */
-export default async ({ data: { bodyText }, context: { space, ai } }: any) => {
+export default async ({
+  event: {
+    data: { request },
+  },
+  context: { space, ai },
+}: any) => {
+  const textBody = await request.text();
   let parsedRequest: any;
   try {
-    parsedRequest = JSON.parse(bodyText);
+    parsedRequest = JSON.parse(textBody);
   } catch (err) {
     const answer = await ai.run('@cf/meta/llama-3.1-8b-instruct', {
       stream: true,
@@ -23,7 +29,7 @@ export default async ({ data: { bodyText }, context: { space, ai } }: any) => {
      ${await getContext({ space })}
 
      QUESTION:
-     ${bodyText}
+     ${textBody}
     `,
     });
     return new Response(transformServerSentEvents(answer));

package/src/templates/chess.ts

@@ -25,7 +25,12 @@ export default defineFunction({
     }),
   }),
 
-  handler: async ({ data: { changedObjectId, player = 'b' }, context: { space } }: any) => {
+  handler: async ({
+    event: {
+      data: { changedObjectId, player = 'b' },
+    },
+    context: { space },
+  }: any) => {
     const { pgn } = await space.db.query({ id: changedObjectId }).first();
     const game = new Chess();
     game.load_pgn(pgn);

package/src/templates/data-generator.ts

@@ -2,10 +2,35 @@
 // Copyright 2025 DXOS.org
 //
 
+import {
+  EchoObject,
+  defineFunction,
+  S,
+  createStatic,
+  Expando,
+  TypedObject,
+  Ref,
+  LabelAnnotationId,
+  // @ts-ignore
+} from 'dxos:functions';
 // @ts-ignore
-import { defineFunction, S, create, Expando } from 'dxos:functions';
-// @ts-ignore
-import { randText } from 'https://esm.sh/@ngneat/falso@7.1.1';
+import { randParagraph } from 'https://esm.sh/@ngneat/falso@7.1.1';
+
+export class TextType extends TypedObject({ typename: 'dxos.org/type/Text', version: '0.1.0' })({
+  content: S.String,
+}) {}
+
+export const DocumentSchema = S.Struct({
+  name: S.optional(S.String),
+  fallbackName: S.optional(S.String),
+  content: Ref(TextType),
+  threads: S.mutable(S.Array(Ref(Expando))),
+}).annotations({
+  [LabelAnnotationId]: ['name', 'fallbackName'],
+});
+
+export const DocumentType = DocumentSchema.pipe(EchoObject('dxos.org/type/Document', '0.1.0'));
+export type DocumentType = S.Schema.Type<typeof DocumentType>;
 
 export default defineFunction({
   inputSchema: S.Struct({
@@ -16,33 +41,33 @@ export default defineFunction({
 
   outputSchema: S.Struct({}),
 
-  handler: async ({ data: { documentAmount = 1, textSize = 10, mutationAmount = 0 }, context: { space } }: any) => {
+  handler: async ({ event: { documentAmount = 10, textSize = 10, mutationAmount = 0 }, context: { space } }: any) => {
     await space.db.graph.schemaRegistry.addSchema([Expando]);
-    const result: Record<string, any> = {};
-    const objects: Expando[] = [];
 
-    // Create objects.
+    const objects = [];
+    // const rootCollection = await space.properties[COLLECTION_TYPENAME]?.load();
     for (let i = 0; i < documentAmount; i++) {
       const obj = space.db.add(
-        create(Expando, {
+        createStatic(Expando, {
           name: 'scriptGenerated',
-          content: randText({ charCount: textSize }),
+          content: randParagraph({ length: textSize }),
         }),
       );
+      // rootCollection.objects.push(obj);
       objects.push(obj);
-      const objectResult: any = {};
-      // Mutate the object.
-      for (let i = 0; i < mutationAmount; i++) {
-        obj.content = randText({ charCount: textSize });
-      }
-      objectResult.mutations = mutationAmount;
-      objectResult.contentLength = obj.content.length;
-      result[obj.id] = objectResult;
     }
 
-    // Flush and wait for data to propagate.
+    for (let i = 0; i < mutationAmount; i++) {
+      const obj = objects[Math.floor(Math.random() * objects.length)];
+      obj.content = randParagraph({ length: textSize });
+    }
+
     await space.db.flush();
-    await new Promise((resolve) => setTimeout(resolve, 10_000));
-    return result;
+    // TODO(mykola): This seems to halp with propagating data to space.
+    for (const obj of objects) {
+      await space.db.query({ id: obj.id }).first();
+      console.log('obj', obj.id);
+    }
+    return 'OK';
   },
 });

package/src/templates/discord.ts

@@ -3,7 +3,7 @@
 //
 
 // @ts-ignore
-import { create, defineFunction, DXN, EchoObject, Filter, ObjectId, S } from 'dxos:functions';
+import { createStatic, EchoObject, defineFunction, DXN, Filter, ObjectId, S } from 'dxos:functions';
 import {
   FetchHttpClient,
   // @ts-ignore
@@ -14,17 +14,12 @@ import { DiscordConfig, DiscordREST, DiscordRESTMemoryLive } from 'https://esm.s
 import { Effect, Config, Redacted, Ref } from 'https://esm.sh/effect@3.13.3';
 
 const MessageSchema = S.Struct({
-  id: ObjectId,
+  id: S.String,
   foreignId: S.Any, // bigint?
   from: S.String,
   created: S.String,
   content: S.String,
-}).pipe(
-  EchoObject({
-    typename: 'example.com/type/Message',
-    version: '0.1.0',
-  }),
-);
+}).pipe(EchoObject({ typename: 'example.com/type/Message', version: '0.1.0' }));
 
 const DEFAULT_AFTER = 1704067200; // 2024-01-01
 
@@ -47,7 +42,12 @@ export default defineFunction({
     newMessages: S.Number,
   }),
 
-  handler: ({ data: { channelId, queueId, after = DEFAULT_AFTER, pageSize = 5 }, context: { space } }: any) =>
+  handler: ({
+    event: {
+      data: { channelId, queueId, after = DEFAULT_AFTER, pageSize = 5 },
+    },
+    context: { space },
+  }: any) =>
     Effect.gen(function* () {
       const { token } = yield* Effect.tryPromise({
         try: () => space.db.query(Filter.typename('dxos.org/type/AccessToken', { source: 'discord.com' })).first(),
@@ -73,7 +73,7 @@ export default defineFunction({
           const messages = yield* rest.getChannelMessages(channelId, options).pipe((res: any) => res.json);
           const queueMessages = messages
             .map((message: any) =>
-              create(MessageSchema, {
+              createStatic(MessageSchema, {
                 id: ObjectId.random(),
                 foreignId: message.id,
                 from: message.author.username,

package/src/templates/echo.ts

@@ -5,4 +5,15 @@
 /**
  * Echos the request data.
  */
-export default async ({ data }: any) => data;
+export default async ({
+  event: {
+    data: { request },
+  },
+}: any) => {
+  const data = await request.json();
+  return new Response(JSON.stringify(data ?? {}), {
+    headers: {
+      'Content-Type': 'application/json',
+    },
+  });
+};

package/src/templates/email.ts

@@ -6,9 +6,15 @@
  * Appends a message to the end of a Document configured through a trigger.
  * Trigger must have a targetDocumentId field set in Meta.
  */
-export default async ({ data: { bodyText }, context: { space } }: any) => {
-  const { email, targetDocumentId: documentId } = JSON.parse(bodyText) as RequestPayload;
+export default async ({
+  event: {
+    data: { request },
+  },
+  context: { space },
+}: any) => {
+  const { data, trigger } = (await request.json()) as RequestPayload;
 
+  const documentId = trigger.meta.targetDocumentId;
   const document = await space.db.query({ id: documentId }, { format: 'plain' }).first();
 
   const contentId = document.content['/'].split(':')[3];
@@ -17,11 +23,11 @@ export default async ({ data: { bodyText }, context: { space } }: any) => {
     documentContent.content,
     '',
     '---',
-    `**From:** ${email.from}`,
-    `**Subject:** ${email.subject}`,
-    `**Date:** ${email.created}`,
+    `**From:** ${data.from}`,
+    `**Subject:** ${data.subject}`,
+    `**Date:** ${data.created}`,
     '',
-    email.body,
+    data.body,
   ].join('\n');
 
   await space.db.update({ id: contentId }, { content: modifiedContent });
@@ -30,6 +36,6 @@ export default async ({ data: { bodyText }, context: { space } }: any) => {
 };
 
 type RequestPayload = {
-  email: { from: string; subject: string; created: string; body: string };
-  targetDocumentId: string;
+  data: { from: string; subject: string; created: string; body: string };
+  trigger: { meta: { targetDocumentId: string } };
 };

package/src/templates/forex-effect.ts

@@ -3,7 +3,7 @@
 //
 
 // @ts-ignore
-import { S, defineFunction } from 'dxos:functions';
+import { defineFunction, S } from 'dxos:functions';
 import {
   HttpClient,
   HttpClientRequest,
@@ -23,7 +23,11 @@ export default defineFunction({
 
   outputSchema: S.String.annotations({ description: 'The exchange rate between the two currencies' }),
 
-  handler: async ({ data: { from, to } }: any) =>
+  handler: async ({
+    event: {
+      data: { from, to },
+    },
+  }: any) =>
     Effect.gen(function* () {
       const res = yield* HttpClientRequest.get(`https://free.ratesdb.com/v1/rates?from=${from}&to=${to}`).pipe(
         HttpClient.execute,

package/src/templates/forex.ts

@@ -13,7 +13,11 @@ export default defineFunction({
     to: S.String.annotations({ description: 'The target currency' }),
   }),
 
-  handler: async ({ data: { from, to } }: any) => {
+  handler: async ({
+    event: {
+      data: { from, to },
+    },
+  }: any) => {
     const res = await fetch(`https://free.ratesdb.com/v1/rates?from=${from}&to=${to}`);
     const {
       data: { rates },

package/src/templates/gmail.ts

@@ -3,8 +3,7 @@
 //
 
 // @ts-ignore
-import { create, defineFunction, EchoObject, Filter, ObjectId, S } from 'dxos:functions';
-// @ts-ignore
+import { createStatic, defineFunction, EchoObject, Filter, ObjectId, S } from 'dxos:functions';
 import {
   HttpClient,
   HttpClientRequest,
@@ -12,37 +11,40 @@ import {
   // @ts-ignore
 } from 'https://esm.sh/@effect/platform@0.77.2?deps=effect@3.13.3';
 // @ts-ignore
-import { format, subDays } from 'https://esm.sh/date-fns@3.3.1';
-// @ts-ignore
 import { pipe, Chunk, Effect, Ref, Schedule, Stream } from 'https://esm.sh/effect@3.13.3';
 
+// TODO(ZaymonFC): Calculate this dynamically and expose a parameter.
+const DEFAULT_AFTER = '2025-01-01';
+
 export default defineFunction({
   inputSchema: S.Struct({
-    mailboxId: S.String,
-    userId: S.optional(S.String).pipe(S.withDecodingDefault(() => 'me')),
-    after: S.optional(S.Union(S.Number, S.String)).pipe(
-      S.withDecodingDefault(() => format(subDays(new Date(), 30), 'yyyy-MM-dd')),
-    ),
-    pageSize: S.optional(S.Number).pipe(S.withDecodingDefault(() => 100)),
     // TODO(wittjosiah): Remove. This is used to provide a terminal for a cron trigger.
     tick: S.optional(S.String),
+    userId: S.optional(S.String),
+    after: S.optional(S.Union(S.Number, S.String)),
+    pageSize: S.optional(S.Number),
+    mailboxId: S.String,
   }),
 
   outputSchema: S.Struct({
     newMessages: S.Number,
   }),
 
-  handler: ({ context: { space }, data: { mailboxId, userId, after, pageSize } }: any) =>
+  handler: ({
+    event: {
+      data: { mailboxId, userId = 'me', after = DEFAULT_AFTER, pageSize = 100 },
+    },
+    context: { space },
+  }: any) =>
     Effect.gen(function* () {
       const { token } = yield* Effect.tryPromise({
         try: () => space.db.query(Filter.typename('dxos.org/type/AccessToken', { source: 'gmail.com' })).first(),
         catch: (e: any) => e,
       });
 
-      // NOTE: Google API bundles size is v. large and caused runtime issues.
-      const makeRequest = (url: string) =>
+      const makeRequest = (path: string) =>
         pipe(
-          url,
+          path,
           HttpClientRequest.get,
           HttpClientRequest.setHeaders({ Authorization: `Bearer ${token}`, Accept: 'application/json' }),
           HttpClient.execute,
@@ -52,10 +54,13 @@ export default defineFunction({
           Effect.scoped,
         );
 
-      const listMessages = (userId: string, q: string, pageSize: number, pageToken: string | null) =>
-        makeRequest(getUrl(userId, undefined, { q, pageSize, pageToken }));
+      const listMessages = (userId: string, q: string, pageSize: number, pageToken: string | null) => {
+        const url = `https://gmail.googleapis.com/gmail/v1/users/${userId}/messages?maxResults=${pageSize}&q=${q}`;
+        return makeRequest(pageToken ? `${url}&pageToken=${pageToken}` : url);
+      };
 
-      const getMessage = (userId: string, messageId: string) => makeRequest(getUrl(userId, messageId));
+      const getMessage = (userId: string, id: string) =>
+        makeRequest(`https://gmail.googleapis.com/gmail/v1/users/${userId}/messages/${id}`);
 
       const mailbox = yield* Effect.tryPromise({
         try: () => space.db.query({ id: mailboxId }).first(),
@@ -92,7 +97,7 @@ export default defineFunction({
             continue;
           }
           const subject = messageDetails.payload.headers.find((h: any) => h.name === 'Subject')?.value;
-          const object = create(MessageType, {
+          const object = createStatic(MessageType, {
             id: ObjectId.random(),
             created,
             sender,
@@ -132,14 +137,6 @@ export default defineFunction({
     }).pipe(Effect.provide(FetchHttpClient.layer)),
 });
 
-const getUrl = (userId: string, messageId?: string, params?: Record<string, any>) => {
-  const api = new URL(
-    [`https://gmail.googleapis.com/gmail/v1/users/${userId}/messages`, messageId].filter(Boolean).join('/'),
-  );
-  Object.entries(params ?? {}).forEach(([key, value]) => api.searchParams.set(key, value));
-  return api.toString();
-};
-
 /**
  * Parses an email string in the format "Name <email@example.com>" into separate name and email components.
  */
@@ -156,9 +153,10 @@ const parseEmailString = (emailString: string): { name?: string; email: string }
   return undefined;
 };
 
+// TODO(wittjosiah): These schemas should be imported from @dxos/schema.
+
 //
 // Schemas
-// TODO(wittjosiah): These schemas should be imported from @dxos/S.
 //
 
 const ActorRoles = ['user', 'assistant'] as const;
@@ -242,10 +240,5 @@ const MessageType = S.Struct({
       }),
     ),
   ),
-}).pipe(
-  EchoObject({
-    typename: 'dxos.org/type/Message',
-    version: '0.1.0',
-  }),
-);
+}).pipe(EchoObject({ typename: 'dxos.org/type/Message', version: '0.1.0' }));
 type MessageType = S.Schema.Type<typeof MessageType>;

package/src/translations.ts

@@ -2,7 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
-import { ScriptType } from '@dxos/functions';
+import { ScriptType } from '@dxos/functions/types';
 
 import { SCRIPT_PLUGIN } from './meta';
 

package/src/types.ts

@@ -2,10 +2,11 @@
 // Copyright 2023 DXOS.org
 //
 
-import { Schema, SchemaAST } from 'effect';
+import { TitleAnnotationId } from 'effect/SchemaAST';
 
 import { SpaceSchema } from '@dxos/client/echo';
-import { ScriptType } from '@dxos/functions';
+import { S } from '@dxos/echo-schema';
+import { ScriptType } from '@dxos/functions/types';
 import { EditorInputMode } from '@dxos/react-ui-editor';
 
 import { SCRIPT_PLUGIN } from './meta';
@@ -16,27 +17,27 @@ export { SCRIPT_PLUGIN };
 export namespace ScriptAction {
   const SCRIPT_ACTION = `${SCRIPT_PLUGIN}/action`;
 
-  export const CreateScriptSchema = Schema.Struct({
-    name: Schema.optional(Schema.String),
+  export const CreateScriptSchema = S.Struct({
+    name: S.optional(S.String),
     // TODO(wittjosiah): Placeholder annotation?
-    gistUrl: Schema.optional(Schema.String.annotations({ [SchemaAST.TitleAnnotationId]: 'Import from Gist (url)' })),
-    initialTemplateId: Schema.optional(Schema.String),
+    gistUrl: S.optional(S.String.annotations({ [TitleAnnotationId]: 'Import from Gist (url)' })),
+    initialTemplateId: S.optional(S.String),
   });
 
-  export type CreateScriptProps = Schema.Schema.Type<typeof CreateScriptSchema>;
+  export type CreateScriptProps = S.Schema.Type<typeof CreateScriptSchema>;
 
-  export class Create extends Schema.TaggedClass<Create>()(`${SCRIPT_ACTION}/create`, {
-    input: Schema.extend(CreateScriptSchema, Schema.Struct({ space: SpaceSchema })),
-    output: Schema.Struct({
+  export class Create extends S.TaggedClass<Create>()(`${SCRIPT_ACTION}/create`, {
+    input: S.extend(CreateScriptSchema, S.Struct({ space: SpaceSchema })),
+    output: S.Struct({
       object: ScriptType,
     }),
   }) {}
 }
 
-export const ScriptSettingsSchema = Schema.mutable(
-  Schema.Struct({
+export const ScriptSettingsSchema = S.mutable(
+  S.Struct({
     editorInputMode: EditorInputMode,
   }),
 );
 
-export type ScriptSettingsProps = Schema.Schema.Type<typeof ScriptSettingsSchema>;
+export type ScriptSettingsProps = S.Schema.Type<typeof ScriptSettingsSchema>;

package/src/util/deploy.ts

@@ -7,13 +7,13 @@ import {
   FunctionType,
   type ScriptType,
   getUserFunctionUrlInMetadata,
-  makeFunctionUrl,
+  incrementSemverPatch,
   setUserFunctionUrlInMetadata,
+  uploadWorkerFunction,
 } from '@dxos/functions';
 import { Bundler } from '@dxos/functions/bundler';
-import { incrementSemverPatch, uploadWorkerFunction } from '@dxos/functions/edge';
 import { log } from '@dxos/log';
-import { live, getMeta, makeRef, type Space } from '@dxos/react-client/echo';
+import { create, getMeta, makeRef, type Space } from '@dxos/react-client/echo';
 
 import { updateFunctionMetadata } from './functions';
 
@@ -57,7 +57,7 @@ export const deployScript = async ({
 
     const { functionId, version, meta } = await uploadWorkerFunction({
       client,
-      ownerPublicKey: space.key,
+      spaceId: space.id,
       version: fn ? incrementSemverPatch(fn.version) : '0.0.1',
       functionId: existingFunctionId,
       source: bundle,
@@ -71,7 +71,7 @@ export const deployScript = async ({
     script.changed = false;
     updateFunctionMetadata(script, storedFunction, meta, functionId);
 
-    const functionUrl = makeFunctionUrl({ functionId });
+    const functionUrl = makeFunctionUrl(space.id, functionId);
     setUserFunctionUrlInMetadata(getMeta(storedFunction), functionUrl);
 
     return { success: true, functionUrl };
@@ -117,6 +117,10 @@ const createOrUpdateFunctionInSpace = (
     fn.version = version;
     return fn;
   } else {
-    return space.db.add(live(FunctionType, { name: functionId, version, source: makeRef(script) }));
+    return space.db.add(create(FunctionType, { name: functionId, version, source: makeRef(script) }));
   }
 };
+
+const makeFunctionUrl = (spaceId: string, functionId: string): string => {
+  return `/${spaceId}/${functionId}`;
+};