@dxos/assistant-toolkit 0.8.4-main.ae835ea → 0.8.4-main.bc2380dfbc

package/src/{functions/linear → blueprints/linear/functions}/sync-issues.ts

@@ -7,15 +7,16 @@ import * as HttpClient from '@effect/platform/HttpClient';
 import * as Array from 'effect/Array';
 import * as Effect from 'effect/Effect';
 import * as Function from 'effect/Function';
-import * as Schema from 'effect/Schema';
 
-import { Filter, Obj, Query, Ref, type Type } from '@dxos/echo';
-import { DatabaseService, defineFunction, withAuthorization } from '@dxos/functions';
+import { Credential, Operation } from '@dxos/compute';
+import { Database, Filter, Obj, Query, Ref, type Type } from '@dxos/echo';
+import { withAuthorization } from '@dxos/functions';
 import { log } from '@dxos/log';
-import { DataType } from '@dxos/schema';
+import { Person, Pipeline, Task } from '@dxos/types';
 
-import { syncObjects } from '../../sync';
-import { graphqlRequestBody } from '../../util';
+import { syncObjects } from '../../../sync';
+import { graphqlRequestBody } from '../../../util';
+import { SyncIssues } from './definitions';
 
 const queryIssues = `
 query Issues($teamId: String!, $after: DateTimeOrDuration!) {
@@ -35,7 +36,7 @@ query Issues($teamId: String!, $after: DateTimeOrDuration!) {
             updatedAt
             description
             assignee { id, name }
-            state { 
+            state {
                 name
             }
             project {
@@ -74,48 +75,40 @@ export const LINEAR_ID_KEY = 'linear.app/id';
 export const LINEAR_TEAM_ID_KEY = 'linear.app/teamId';
 export const LINEAR_UPDATED_AT_KEY = 'linear.app/updatedAt';
 
-export default defineFunction({
-  key: 'dxos.org/function/linear/sync-issues',
-  name: 'Linear',
-  description: 'Sync issues from Linear.',
-  inputSchema: Schema.Struct({
-    team: Schema.String.annotations({
-      description: 'Linear team id.',
-    }),
-  }),
-  handler: Effect.fnUntraced(function* ({ data }) {
-    const client = yield* HttpClient.HttpClient.pipe(Effect.map(withAuthorization({ service: 'linear.app' })));
-
-    // Get the timestamp that was previosly synced.
-    const after = yield* getLatestUpdateTimestamp(data.team, DataType.Task);
-    log.info('will fetch', { after });
-
-    // Fetch the issues that have changed since the last sync.
-    const response = yield* client.post('https://api.linear.app/graphql', {
-      body: yield* graphqlRequestBody(queryIssues, {
-        teamId: data.team,
-        after,
-      }),
-    });
-    const json: any = yield* response.json;
-    const tasks = (json.data.team.issues.edges as any[]).map((edge: any) =>
-      mapLinearIssue(edge.node as LinearIssue, { teamId: data.team }),
-    );
-    log.info('Fetched tasks', { count: tasks.length });
-
-    // Synchronize new objects with ECHO.
-    return {
-      objects: yield* syncObjects(tasks, { foreignKeyId: LINEAR_ID_KEY }),
-      syncComplete: tasks.length < 150,
-    };
-  }, Effect.provide(FetchHttpClient.layer)),
-});
+export default SyncIssues.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ team }) {
+      const credential = yield* Credential.CredentialsService.getCredential({ service: 'linear.app' });
+      const client = yield* HttpClient.HttpClient.pipe(Effect.map(withAuthorization(credential.apiKey!)));
+
+      const after = yield* getLatestUpdateTimestamp(team, Task.Task);
+      log.info('will fetch', { after });
+
+      const response = yield* client.post('https://api.linear.app/graphql', {
+        body: yield* graphqlRequestBody(queryIssues, {
+          teamId: team,
+          after,
+        }),
+      });
+      const json: any = yield* response.json;
+      const tasks = (json.data.team.issues.edges as any[]).map((edge: any) =>
+        mapLinearIssue(edge.node as LinearIssue, { teamId: team }),
+      );
+      log.info('Fetched tasks', { count: tasks.length });
+
+      return {
+        objects: yield* syncObjects(tasks, { foreignKeyId: LINEAR_ID_KEY }),
+        syncComplete: tasks.length < 150,
+      };
+    }, Effect.provide(FetchHttpClient.layer)),
+  ),
+);
 
 const getLatestUpdateTimestamp: (
   teamId: string,
-  dataType: Type.Obj.Any,
-) => Effect.Effect<string, never, DatabaseService> = Effect.fnUntraced(function* (teamId, dataType) {
-  const { objects: existingTasks } = yield* DatabaseService.runQuery(
+  dataType: Type.AnyObj,
+) => Effect.Effect<string, never, Database.Service> = Effect.fnUntraced(function* (teamId, dataType) {
+  const existingTasks = yield* Database.runQuery(
     Query.type(dataType).select(Filter.foreignKeys(dataType, [{ source: LINEAR_TEAM_ID_KEY, id: teamId }])),
   );
   return Function.pipe(
@@ -126,8 +119,8 @@ const getLatestUpdateTimestamp: (
   );
 });
 
-const mapLinearPerson = (person: LinearPerson, { teamId }: { teamId: string }): DataType.Person =>
-  Obj.make(DataType.Person, {
+const mapLinearPerson = (person: LinearPerson, { teamId }: { teamId: string }): Person.Person =>
+  Obj.make(Person.Person, {
     [Obj.Meta]: {
       keys: [
         {
@@ -143,8 +136,8 @@ const mapLinearPerson = (person: LinearPerson, { teamId }: { teamId: string }):
     nickname: person.name,
   });
 
-const mapLinearIssue = (issue: LinearIssue, { teamId }: { teamId: string }): DataType.Task =>
-  Obj.make(DataType.Task, {
+const mapLinearIssue = (issue: LinearIssue, { teamId }: { teamId: string }): Task.Task =>
+  Obj.make(Task.Task, {
     [Obj.Meta]: {
       keys: [
         {
@@ -170,7 +163,7 @@ const mapLinearIssue = (issue: LinearIssue, { teamId }: { teamId: string }): Dat
     project: !issue.project
       ? undefined
       : Ref.make(
-          DataType.makeProject({
+          Pipeline.make({
             [Obj.Meta]: {
               keys: [
                 {

package/src/blueprints/linear/index.ts

@@ -2,6 +2,5 @@
 // Copyright 2025 DXOS.org
 //
 
-import blueprint from './linear-blueprint';
-
-export default blueprint;
+export { default as LinearBlueprint } from './blueprint';
+export { SyncIssues, LinearHandlers } from './functions';