@dxos/plugin-script 0.8.2-main.2f9c567 → 0.8.2-main.30e4dbb

package/src/hooks/deploy.ts

@@ -2,13 +2,13 @@
 // Copyright 2025 DXOS.org
 //
 
-import { useCallback, useEffect, useMemo } from 'react';
+import { useEffect, useMemo } from 'react';
 
 import { FunctionType, type ScriptType, getUserFunctionUrlInMetadata } from '@dxos/functions';
 import { log } from '@dxos/log';
-import { useClient } from '@dxos/react-client';
-import { Filter, getMeta, getSpace, useQuery } from '@dxos/react-client/echo';
-import { useTranslation } from '@dxos/react-ui';
+import { type Client, useClient } from '@dxos/react-client';
+import { Filter, getMeta, getSpace, type Space, useQuery } from '@dxos/react-client/echo';
+import { type TFunction } from '@dxos/react-ui';
 import { createMenuAction } from '@dxos/react-ui-menu';
 import { errorMessageColors } from '@dxos/react-ui-theme';
 
@@ -24,28 +24,68 @@ export type DeployState = {
   error: string;
 };
 
-export const createDeploy = (state: Partial<DeployState>) => {
-  const errorItem = createMenuAction('error', {
+export type CreateDeployOptions = {
+  state: Partial<DeployState>;
+  script: ScriptType;
+  fn: FunctionType;
+  space?: Space;
+  existingFunctionUrl?: string;
+  client: Client;
+  t: TFunction;
+};
+
+export const createDeploy = ({ state, script, space, fn, client, existingFunctionUrl, t }: CreateDeployOptions) => {
+  // TODO(wittjosiah): Should this be an action?
+  const errorItem = createMenuAction('error', () => {}, {
     label: state.error ?? ['no error label', { ns: SCRIPT_PLUGIN }],
     icon: 'ph--warning-circle--regular',
     hidden: !state.error,
     classNames: state.error && errorMessageColors,
   });
 
-  const deployAction = createMenuAction<DeployActionProperties>('deploy', {
-    type: 'deploy',
-    label: [state.deploying ? 'pending label' : 'deploy label', { ns: SCRIPT_PLUGIN }],
-    icon: state.deploying ? 'ph--spinner-gap--regular' : 'ph--cloud-arrow-up--regular',
-    disabled: state.deploying,
-    classNames: state.deploying ? '[&_svg]:animate-spin' : '',
-  });
-
-  const copyAction = createMenuAction<DeployActionProperties>('copy', {
-    type: 'copy',
-    label: ['copy link label', { ns: SCRIPT_PLUGIN }],
-    icon: 'ph--link--regular',
-    disabled: !state.functionUrl,
-  });
+  const deployAction = createMenuAction<DeployActionProperties>(
+    'deploy',
+    async () => {
+      if (!script.source || !space) {
+        return;
+      }
+
+      state.error = undefined;
+      state.deploying = true;
+
+      const result = await deployScript({ script, client, space, fn, existingFunctionUrl });
+
+      if (!result.success) {
+        log.catch(result.error);
+        state.error = t('upload failed label');
+      }
+
+      state.deploying = false;
+    },
+    {
+      type: 'deploy',
+      label: [state.deploying ? 'pending label' : 'deploy label', { ns: SCRIPT_PLUGIN }],
+      icon: state.deploying ? 'ph--spinner-gap--regular' : 'ph--cloud-arrow-up--regular',
+      disabled: state.deploying,
+      classNames: state.deploying ? '[&_svg]:animate-spin' : '',
+    },
+  );
+
+  const copyAction = createMenuAction<DeployActionProperties>(
+    'copy',
+    async () => {
+      if (!state.functionUrl) {
+        return;
+      }
+      await navigator.clipboard.writeText(state.functionUrl);
+    },
+    {
+      type: 'copy',
+      label: ['copy link label', { ns: SCRIPT_PLUGIN }],
+      icon: 'ph--link--regular',
+      disabled: !state.functionUrl,
+    },
+  );
 
   return {
     nodes: [errorItem, deployAction, copyAction],
@@ -83,37 +123,3 @@ export const useDeployDeps = ({ script }: { script: ScriptType }) => {
   const existingFunctionUrl = useMemo(() => fn && getUserFunctionUrlInMetadata(getMeta(fn)), [fn]);
   return { space, fn, client, existingFunctionUrl };
 };
-
-/**
- * Manage EDGE function deployment.
- */
-export const useDeployHandler = ({ state, script }: { state: Partial<DeployState>; script: ScriptType }) => {
-  const { space, fn, client, existingFunctionUrl } = useDeployDeps({ script });
-  const { t } = useTranslation(SCRIPT_PLUGIN);
-
-  return useCallback(async () => {
-    if (!script.source || !space) {
-      return;
-    }
-
-    state.error = undefined;
-    state.deploying = true;
-
-    const result = await deployScript({ script, client, space, fn, existingFunctionUrl });
-
-    if (!result.success) {
-      log.catch(result.error);
-      state.error = t('upload failed label');
-    }
-
-    state.deploying = false;
-  }, [fn, client, t, existingFunctionUrl, script, space]);
-};
-
-export const useCopyHandler = ({ state }: { state: Partial<DeployState> }) =>
-  useCallback(async () => {
-    if (!state.functionUrl) {
-      return;
-    }
-    await navigator.clipboard.writeText(state.functionUrl);
-  }, [state.functionUrl]);

package/src/hooks/format.ts

@@ -5,7 +5,6 @@
 import { format } from 'prettier';
 import prettierPluginEstree from 'prettier/plugins/estree';
 import prettierPluginTypescript from 'prettier/plugins/typescript';
-import { useCallback } from 'react';
 
 import { type ScriptType } from '@dxos/functions';
 import { log } from '@dxos/log';
@@ -15,33 +14,34 @@ import { SCRIPT_PLUGIN } from '../meta';
 
 export type FormatActionProperties = { type: 'format' };
 
-export const createFormat = () => {
-  const formatAction = createMenuAction('format', {
-    label: ['format label', { ns: SCRIPT_PLUGIN }],
-    icon: 'ph--magic-wand--regular',
-  });
+export const createFormat = (script: ScriptType) => {
+  const formatAction = createMenuAction(
+    'format',
+    async () => {
+      if (!script.source) {
+        return;
+      }
+
+      try {
+        script.source.target!.content = await format(script.source.target!.content, {
+          parser: 'typescript',
+          plugins: [prettierPluginEstree, prettierPluginTypescript],
+          semi: true,
+          singleQuote: true,
+        });
+      } catch (err: any) {
+        // TODO(wittjosiah): Show error in UI.
+        log.catch(err);
+      }
+    },
+    {
+      label: ['format label', { ns: SCRIPT_PLUGIN }],
+      icon: 'ph--magic-wand--regular',
+    },
+  );
 
   return {
     nodes: [formatAction],
     edges: [{ source: 'root', target: 'format' }],
   };
 };
-
-export const useFormatHandler = ({ script }: { script: ScriptType }) =>
-  useCallback(async () => {
-    if (!script.source) {
-      return;
-    }
-
-    try {
-      script.source.target!.content = await format(script.source.target!.content, {
-        parser: 'typescript',
-        plugins: [prettierPluginEstree, prettierPluginTypescript],
-        semi: true,
-        singleQuote: true,
-      });
-    } catch (err: any) {
-      // TODO(wittjosiah): Show error in UI.
-      log.catch(err);
-    }
-  }, [script.source]);

package/src/hooks/index.ts

@@ -7,5 +7,4 @@ export * from './format';
 export * from './template';
 
 export * from './useCreateAndDeployScriptTemplates';
-export * from './useToolbarAction';
 export * from './useToolbarState';

package/src/hooks/template.ts

@@ -2,8 +2,6 @@
 // Copyright 2025 DXOS.org
 //
 
-import { useCallback } from 'react';
-
 import { FUNCTIONS_PRESET_META_KEY, type ScriptType } from '@dxos/functions';
 import { getMeta } from '@dxos/live-object';
 import { createMenuItemGroup, createMenuAction } from '@dxos/react-ui-menu';
@@ -20,19 +18,34 @@ const createTemplateSelectGroup = () => {
   });
 };
 
-const createTemplateSelectActions = () => {
+const createTemplateSelectActions = (script: ScriptType) => {
   return templates.map((template) => {
-    return createMenuAction<TemplateActionProperties>(`template--${template.id}`, {
-      label: template.name,
-      value: template.id,
-      type: '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',
+      },
+    );
   });
 };
 
-export const createTemplateSelect = () => {
+export const createTemplateSelect = (script: ScriptType) => {
   const templateSelectGroup = createTemplateSelectGroup();
-  const templateSelectActions = createTemplateSelectActions();
+  const templateSelectActions = createTemplateSelectActions(script);
   return {
     nodes: [templateSelectGroup, ...templateSelectActions],
     edges: [
@@ -41,24 +54,3 @@ export const createTemplateSelect = () => {
     ],
   };
 };
-
-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/templates/chess.ts

@@ -2,26 +2,25 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
 // @ts-ignore
-import { defineFunction } from 'dxos:functions';
+import { defineFunction, S } from 'dxos:functions';
 // @ts-ignore
 import { Chess } from 'https://esm.sh/chess.js@0.13.1';
 
 export default defineFunction({
   description: 'Plays a random move in a chess game.',
 
-  inputSchema: Schema.Struct({
-    changedObjectId: Schema.String.annotations({
+  inputSchema: S.Struct({
+    changedObjectId: S.String.annotations({
       description: 'The objects to play the game on.',
     }),
-    player: Schema.optional(Schema.Literal('w', 'b')).annotations({
+    player: S.optional(S.Literal('w', 'b')).annotations({
       description: 'The player to play the game as.',
     }),
   }),
 
-  outputSchema: Schema.Struct({
-    state: Schema.String.annotations({
+  outputSchema: S.Struct({
+    state: S.String.annotations({
       description: 'The state of the game as an ASCII art board.',
     }),
   }),

package/src/templates/data-generator.ts

@@ -2,20 +2,19 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
 // @ts-ignore
 import { defineFunction, S, create, Expando } from 'dxos:functions';
 // @ts-ignore
 import { randText } from 'https://esm.sh/@ngneat/falso@7.1.1';
 
 export default defineFunction({
-  inputSchema: Schema.Struct({
-    documentAmount: Schema.optional(Schema.Number),
-    textSize: Schema.optional(Schema.Number),
-    mutationAmount: Schema.optional(Schema.Number),
+  inputSchema: S.Struct({
+    documentAmount: S.optional(S.Number),
+    textSize: S.optional(S.Number),
+    mutationAmount: S.optional(S.Number),
   }),
 
-  outputSchema: Schema.Struct({}),
+  outputSchema: S.Struct({}),
 
   handler: async ({
     event: {

package/src/templates/discord.ts

@@ -2,7 +2,6 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
 // @ts-ignore
 import { create, defineFunction, DXN, Filter, ObjectId, S } from 'dxos:functions';
 import {
@@ -16,12 +15,12 @@ import { Effect, Config, Redacted, Ref } from 'https://esm.sh/effect@3.13.3';
 
 import { Type } from '@dxos/echo';
 
-const MessageSchema = Schema.Struct({
+const MessageSchema = S.Struct({
   id: ObjectId,
-  foreignId: Schema.Any, // bigint?
-  from: Schema.String,
-  created: Schema.String,
-  content: Schema.String,
+  foreignId: S.Any, // bigint?
+  from: S.String,
+  created: S.String,
+  content: S.String,
 }).pipe(
   Type.def({
     typename: 'example.com/type/Message',
@@ -37,17 +36,17 @@ const generateSnowflake = (unixTimestamp: number): bigint => {
 };
 
 export default defineFunction({
-  inputSchema: Schema.Struct({
+  inputSchema: S.Struct({
     // TODO(wittjosiah): Remove. This is used to provide a terminal for a cron trigger.
-    tick: Schema.optional(Schema.String),
-    channelId: Schema.String,
-    after: Schema.optional(Schema.Number),
-    pageSize: Schema.optional(Schema.Number),
-    queueId: Schema.String,
+    tick: S.optional(S.String),
+    channelId: S.String,
+    after: S.optional(S.Number),
+    pageSize: S.optional(S.Number),
+    queueId: S.String,
   }),
 
-  outputSchema: Schema.Struct({
-    newMessages: Schema.Number,
+  outputSchema: S.Struct({
+    newMessages: S.Number,
   }),
 
   handler: ({

package/src/templates/forex-effect.ts

@@ -2,9 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
 // @ts-ignore
-import { defineFunction } from 'dxos:functions';
+import { S, defineFunction } from 'dxos:functions';
 import {
   HttpClient,
   HttpClientRequest,
@@ -17,12 +16,12 @@ import { Effect, Schedule } from 'https://esm.sh/effect@3.13.3';
 export default defineFunction({
   description: 'Returns the exchange rate between two currencies.',
 
-  inputSchema: Schema.Struct({
-    from: Schema.String.annotations({ description: 'The source currency' }),
-    to: Schema.String.annotations({ description: 'The target currency' }),
+  inputSchema: S.Struct({
+    from: S.String.annotations({ description: 'The source currency' }),
+    to: S.String.annotations({ description: 'The target currency' }),
   }),
 
-  outputSchema: Schema.String.annotations({ description: 'The exchange rate between the two currencies' }),
+  outputSchema: S.String.annotations({ description: 'The exchange rate between the two currencies' }),
 
   handler: async ({
     event: {

package/src/templates/forex.ts

@@ -2,16 +2,15 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
 // @ts-ignore
-import { defineFunction } from 'dxos:functions';
+import { defineFunction, S } from 'dxos:functions';
 
 export default defineFunction({
   description: 'Returns the exchange rate between two currencies.',
 
-  inputSchema: Schema.Struct({
-    from: Schema.String.annotations({ description: 'The source currency' }),
-    to: Schema.String.annotations({ description: 'The target currency' }),
+  inputSchema: S.Struct({
+    from: S.String.annotations({ description: 'The source currency' }),
+    to: S.String.annotations({ description: 'The target currency' }),
   }),
 
   handler: async ({

package/src/templates/gmail.ts

@@ -3,7 +3,7 @@
 //
 
 // @ts-ignore
-import { create, defineFunction, Filter, ObjectId } from 'dxos:functions';
+import { create, defineFunction, Filter, ObjectId, S } from 'dxos:functions';
 // @ts-ignore
 import {
   HttpClient,
@@ -14,24 +14,24 @@ import {
 // @ts-ignore
 import { format, subDays } from 'https://esm.sh/date-fns@3.3.1';
 // @ts-ignore
-import { pipe, Chunk, Effect, Ref, Schedule, Schema, Stream } from 'https://esm.sh/effect@3.13.3';
+import { pipe, Chunk, Effect, Ref, Schedule, Stream } from 'https://esm.sh/effect@3.13.3';
 
 import { Type } from '@dxos/echo';
 
 export default defineFunction({
-  inputSchema: Schema.Struct({
-    mailboxId: Schema.String,
-    userId: Schema.optional(Schema.String).pipe(Schema.withDecodingDefault(() => 'me')),
-    after: Schema.optional(Schema.Union(Schema.Number, Schema.String)).pipe(
-      Schema.withDecodingDefault(() => format(subDays(new Date(), 30), 'yyyy-MM-dd')),
+  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: Schema.optional(Schema.Number).pipe(Schema.withDecodingDefault(() => 100)),
+    pageSize: S.optional(S.Number).pipe(S.withDecodingDefault(() => 100)),
     // TODO(wittjosiah): Remove. This is used to provide a terminal for a cron trigger.
-    tick: Schema.optional(Schema.String),
+    tick: S.optional(S.String),
   }),
 
-  outputSchema: Schema.Struct({
-    newMessages: Schema.Number,
+  outputSchema: S.Struct({
+    newMessages: S.Number,
   }),
 
   handler: ({
@@ -165,86 +165,86 @@ const parseEmailString = (emailString: string): { name?: string; email: string }
 
 //
 // Schemas
-// TODO(wittjosiah): These schemas should be imported from @dxos/schema.
+// TODO(wittjosiah): These schemas should be imported from @dxos/S.
 //
 
 const ActorRoles = ['user', 'assistant'] as const;
-const ActorRole = Schema.Literal(...ActorRoles);
-type ActorRole = Schema.Schema.Type<typeof ActorRole>;
+const ActorRole = S.Literal(...ActorRoles);
+type ActorRole = S.S.Type<typeof ActorRole>;
 
-const ActorSchema = Schema.Struct({
-  identityKey: Schema.optional(Schema.String),
-  email: Schema.optional(Schema.String),
-  name: Schema.optional(Schema.String),
-  role: Schema.optional(ActorRole),
+const ActorSchema = S.Struct({
+  identityKey: S.optional(S.String),
+  email: S.optional(S.String),
+  name: S.optional(S.String),
+  role: S.optional(ActorRole),
 });
 
-const AbstractContentBlock = Schema.Struct({
-  pending: Schema.optional(Schema.Boolean),
+const AbstractContentBlock = S.Struct({
+  pending: S.optional(S.Boolean),
 });
-type AbstractContentBlock = Schema.Schema.Type<typeof AbstractContentBlock>;
-const TextContentBlock = Schema.extend(
+type AbstractContentBlock = S.S.Type<typeof AbstractContentBlock>;
+const TextContentBlock = S.extend(
   AbstractContentBlock,
-  Schema.Struct({
-    type: Schema.Literal('text'),
-    disposition: Schema.optional(Schema.String),
-    text: Schema.String,
+  S.Struct({
+    type: S.Literal('text'),
+    disposition: S.optional(S.String),
+    text: S.String,
   }),
-).pipe(Schema.mutable);
-type TextContentBlock = Schema.Schema.Type<typeof TextContentBlock>;
-const JsonContentBlock = Schema.extend(
+).pipe(S.mutable);
+type TextContentBlock = S.S.Type<typeof TextContentBlock>;
+const JsonContentBlock = S.extend(
   AbstractContentBlock,
-  Schema.Struct({
-    type: Schema.Literal('json'),
-    disposition: Schema.optional(Schema.String),
-    data: Schema.String,
+  S.Struct({
+    type: S.Literal('json'),
+    disposition: S.optional(S.String),
+    data: S.String,
   }),
-).pipe(Schema.mutable);
-type JsonContentBlock = Schema.Schema.Type<typeof JsonContentBlock>;
-const Base64ImageSource = Schema.Struct({
-  type: Schema.Literal('base64'),
-  mediaType: Schema.String,
-  data: Schema.String,
-}).pipe(Schema.mutable);
-const HttpImageSource = Schema.Struct({
-  type: Schema.Literal('http'),
-  url: Schema.String,
-}).pipe(Schema.mutable);
-const ImageSource = Schema.Union(Base64ImageSource, HttpImageSource);
-type ImageSource = Schema.Schema.Type<typeof ImageSource>;
-const ImageContentBlock = Schema.extend(
+).pipe(S.mutable);
+type JsonContentBlock = S.S.Type<typeof JsonContentBlock>;
+const Base64ImageSource = S.Struct({
+  type: S.Literal('base64'),
+  mediaType: S.String,
+  data: S.String,
+}).pipe(S.mutable);
+const HttpImageSource = S.Struct({
+  type: S.Literal('http'),
+  url: S.String,
+}).pipe(S.mutable);
+const ImageSource = S.Union(Base64ImageSource, HttpImageSource);
+type ImageSource = S.S.Type<typeof ImageSource>;
+const ImageContentBlock = S.extend(
   AbstractContentBlock,
-  Schema.Struct({
-    type: Schema.Literal('image'),
-    id: Schema.optional(Schema.String),
-    source: Schema.optional(ImageSource),
+  S.Struct({
+    type: S.Literal('image'),
+    id: S.optional(S.String),
+    source: S.optional(ImageSource),
   }),
-).pipe(Schema.mutable);
-type ImageContentBlock = Schema.Schema.Type<typeof ImageContentBlock>;
-const ReferenceContentBlock = Schema.extend(
+).pipe(S.mutable);
+type ImageContentBlock = S.S.Type<typeof ImageContentBlock>;
+const ReferenceContentBlock = S.extend(
   AbstractContentBlock,
-  Schema.Struct({
-    type: Schema.Literal('reference'),
-    reference: Schema.Any,
+  S.Struct({
+    type: S.Literal('reference'),
+    reference: S.Any,
   }),
-).pipe(Schema.mutable);
-type ReferenceContentBlock = Schema.Schema.Type<typeof ReferenceContentBlock>;
-const MessageContentBlock = Schema.Union(TextContentBlock, JsonContentBlock, ImageContentBlock, ReferenceContentBlock);
+).pipe(S.mutable);
+type ReferenceContentBlock = S.S.Type<typeof ReferenceContentBlock>;
+const MessageContentBlock = S.Union(TextContentBlock, JsonContentBlock, ImageContentBlock, ReferenceContentBlock);
 
-const MessageType = Schema.Struct({
+const MessageType = S.Struct({
   id: ObjectId,
-  created: Schema.String.annotations({
+  created: S.String.annotations({
     description: 'ISO date string when the message was sent.',
   }),
   sender: ActorSchema.annotations({
     description: 'Identity of the message sender.',
   }),
-  blocks: Schema.Array(MessageContentBlock).annotations({
+  blocks: S.Array(MessageContentBlock).annotations({
     description: 'Contents of the message.',
   }),
-  properties: Schema.optional(
-    Schema.mutable(
-      Schema.Record({ key: Schema.String, value: Schema.Any }).annotations({
+  properties: S.optional(
+    S.mutable(
+      S.Record({ key: S.String, value: S.Any }).annotations({
         description: 'Custom properties for specific message types (e.g. attention context, email subject, etc.).',
       }),
     ),
@@ -255,4 +255,4 @@ const MessageType = Schema.Struct({
     version: '0.1.0',
   }),
 );
-type MessageType = Schema.Schema.Type<typeof MessageType>;
+type MessageType = S.S.Type<typeof MessageType>;

package/src/util/deploy.ts

@@ -57,7 +57,6 @@ export const deployScript = async ({
 
     const { functionId, version, meta } = await uploadWorkerFunction({
       client,
-      spaceId: space.id,
       version: fn ? incrementSemverPatch(fn.version) : '0.0.1',
       functionId: existingFunctionId,
       source: bundle,
@@ -71,7 +70,7 @@ export const deployScript = async ({
     script.changed = false;
     updateFunctionMetadata(script, storedFunction, meta, functionId);
 
-    const functionUrl = makeFunctionUrl(space.id, { functionId });
+    const functionUrl = makeFunctionUrl({ functionId });
     setUserFunctionUrlInMetadata(getMeta(storedFunction), functionUrl);
 
     return { success: true, functionUrl };