@mepuka/skygent 0.2.0 → 0.3.0

package/src/graph/relationships.ts

@@ -0,0 +1,129 @@
+import { Graph, Option } from "effect";
+import type { RelationshipView } from "../domain/bsky.js";
+
+export type RelationshipNode = {
+  readonly did?: string;
+  readonly handle?: string;
+  readonly displayName?: string;
+  readonly inputs: ReadonlyArray<string>;
+  readonly notFound?: boolean;
+};
+
+export type RelationshipEdge = {
+  readonly following: boolean;
+  readonly followedBy: boolean;
+  readonly mutual: boolean;
+  readonly blocking: boolean;
+  readonly blockedBy: boolean;
+  readonly blockingByList: boolean;
+  readonly blockedByList: boolean;
+  readonly notFound: boolean;
+};
+
+export type RelationshipEntry = {
+  readonly actor: RelationshipNode;
+  readonly other: RelationshipNode;
+  readonly relationship: RelationshipEdge;
+};
+
+export type RelationshipGraphResult = {
+  readonly graph: Graph.DirectedGraph<RelationshipNode, RelationshipEdge>;
+  readonly actorIndex: Graph.NodeIndex;
+  readonly nodeIndexByKey: Map<string, Graph.NodeIndex>;
+};
+
+const edgeFromRelationship = (relationship: RelationshipView): RelationshipEdge => {
+  if (!("did" in relationship)) {
+    return {
+      following: false,
+      followedBy: false,
+      mutual: false,
+      blocking: false,
+      blockedBy: false,
+      blockingByList: false,
+      blockedByList: false,
+      notFound: true
+    };
+  }
+  const following = typeof relationship.following === "string";
+  const followedBy = typeof relationship.followedBy === "string";
+  const blocking = typeof relationship.blocking === "string";
+  const blockedBy = typeof relationship.blockedBy === "string";
+  const blockingByList = typeof relationship.blockingByList === "string";
+  const blockedByList = typeof relationship.blockedByList === "string";
+  return {
+    following,
+    followedBy,
+    mutual: following && followedBy,
+    blocking,
+    blockedBy,
+    blockingByList,
+    blockedByList,
+    notFound: false
+  };
+};
+
+const nodeFromKey = (key: string): RelationshipNode => ({
+  ...(key.startsWith("did:") ? { did: key } : {}),
+  inputs: [key],
+  notFound: true
+});
+
+export const buildRelationshipGraph = (
+  actorKey: string,
+  nodesByKey: Map<string, RelationshipNode>,
+  relationships: ReadonlyArray<RelationshipView>
+): RelationshipGraphResult => {
+  const base = Graph.directed<RelationshipNode, RelationshipEdge>();
+  const nodeIndexByKey = new Map<string, Graph.NodeIndex>();
+
+  const graph = Graph.mutate(base, (mutable) => {
+    const actorNode = nodesByKey.get(actorKey) ?? nodeFromKey(actorKey);
+    const actorIndex = Graph.addNode(mutable, actorNode);
+    nodeIndexByKey.set(actorKey, actorIndex);
+
+    const ensureNode = (key: string, node: RelationshipNode) => {
+      const existing = nodeIndexByKey.get(key);
+      if (existing !== undefined) {
+        return existing;
+      }
+      const index = Graph.addNode(mutable, node);
+      nodeIndexByKey.set(key, index);
+      return index;
+    };
+
+    for (const relationship of relationships) {
+      const key = "did" in relationship ? relationship.did : relationship.actor;
+      const node = nodesByKey.get(key) ?? nodeFromKey(key);
+      const otherIndex = ensureNode(key, node);
+      Graph.addEdge(mutable, actorIndex, otherIndex, edgeFromRelationship(relationship));
+    }
+  });
+
+  const actorIndex = nodeIndexByKey.get(actorKey);
+  if (actorIndex === undefined) {
+    throw new Error(`Missing actor node for ${actorKey}`);
+  }
+
+  return { graph, actorIndex, nodeIndexByKey };
+};
+
+export const relationshipEntries = (
+  graph: Graph.DirectedGraph<RelationshipNode, RelationshipEdge>
+): ReadonlyArray<RelationshipEntry> => {
+  const edges = Array.from(Graph.values(Graph.edges(graph)));
+  const entries: RelationshipEntry[] = [];
+  for (const edge of edges) {
+    const actor = Option.getOrUndefined(Graph.getNode(graph, edge.source));
+    const other = Option.getOrUndefined(Graph.getNode(graph, edge.target));
+    if (!actor || !other) {
+      continue;
+    }
+    entries.push({ actor, other, relationship: edge.data });
+  }
+  return entries;
+};
+
+export const relationshipMermaid = (
+  graph: Graph.DirectedGraph<RelationshipNode, RelationshipEdge>
+): string => Graph.toMermaid(graph);

package/src/services/jetstream-sync.ts

@@ -583,10 +583,10 @@ export class JetstreamSyncEngine extends Context.Tag("@skygent/JetstreamSyncEngi
                 Stream.interruptWhen(
                   Effect.sleep(config.duration).pipe(
                     Effect.zipRight(
-                      Effect.logWarning(
-                        "Jetstream sync exceeded duration; shutting down.",
-                        { durationMs: Duration.toMillis(config.duration) }
-                      )
+                      reporter.warn("Jetstream sync exceeded duration; shutting down.", {
+                        durationMs: Duration.toMillis(config.duration),
+                        store: config.store.name
+                      })
                     ),
                     Effect.zipRight(safeShutdown)
                   )

package/src/services/lineage-store.ts

@@ -63,6 +63,14 @@ export class LineageStore extends Context.Tag("@skygent/LineageStore")<
      * @returns Effect resolving to void, or StoreIoError on failure
      */
     readonly save: (lineage: StoreLineage) => Effect.Effect<void, StoreIoError>;
+
+    /**
+     * Removes lineage information for a store.
+     *
+     * @param storeName - The name of the store to remove lineage for
+     * @returns Effect resolving to void, or StoreIoError on failure
+     */
+    readonly remove: (storeName: StoreName) => Effect.Effect<void, StoreIoError>;
   }
 >() {
   static readonly layer = Layer.effect(
@@ -83,7 +91,13 @@ export class LineageStore extends Context.Tag("@skygent/LineageStore")<
           .pipe(Effect.mapError(toStoreIoError(lineage.storeName)))
       );
 
-      return LineageStore.of({ get, save });
+      const remove = Effect.fn("LineageStore.remove")((storeName: StoreName) =>
+        lineages
+          .remove(lineageKey(storeName))
+          .pipe(Effect.mapError(toStoreIoError(storeName)))
+      );
+
+      return LineageStore.of({ get, save, remove });
     })
   );
 }

package/src/services/store-commit.ts

@@ -67,6 +67,13 @@ export class StoreCommitter extends Context.Tag("@skygent/StoreCommitter")<
       store: StoreRef,
       event: PostUpsert
     ) => Effect.Effect<EventLogEntry, StoreIoError>;
+    /**
+     * Append multiple upsert events in a single transaction.
+     */
+    readonly appendUpserts: (
+      store: StoreRef,
+      events: ReadonlyArray<PostUpsert>
+    ) => Effect.Effect<ReadonlyArray<EventLogEntry>, StoreIoError>;
 
     /**
      * Append an upsert event only if the post doesn't already exist.
@@ -84,6 +91,13 @@ export class StoreCommitter extends Context.Tag("@skygent/StoreCommitter")<
       store: StoreRef,
       event: PostUpsert
     ) => Effect.Effect<Option.Option<EventLogEntry>, StoreIoError>;
+    /**
+     * Append multiple upsert events if missing in a single transaction.
+     */
+    readonly appendUpsertsIfMissing: (
+      store: StoreRef,
+      events: ReadonlyArray<PostUpsert>
+    ) => Effect.Effect<ReadonlyArray<Option.Option<EventLogEntry>>, StoreIoError>;
 
     /**
      * Append a delete event to the store, removing the post.
@@ -125,6 +139,26 @@ export class StoreCommitter extends Context.Tag("@skygent/StoreCommitter")<
             .pipe(Effect.mapError(toStoreIoError(store.root)))
       );
 
+      const appendUpserts = Effect.fn("StoreCommitter.appendUpserts")(
+        (store: StoreRef, events: ReadonlyArray<PostUpsert>) => {
+          if (events.length === 0) {
+            return Effect.succeed([] as ReadonlyArray<EventLogEntry>);
+          }
+          return storeDb
+            .withClient(store, (client) =>
+              client.withTransaction(
+                Effect.forEach(events, (event) =>
+                  Effect.gen(function* () {
+                    yield* upsertPost(client, event.post);
+                    return yield* writer.appendWithClient(client, event);
+                  })
+                )
+              )
+            )
+            .pipe(Effect.mapError(toStoreIoError(store.root)));
+        }
+      );
+
       const appendUpsertIfMissing = Effect.fn(
         "StoreCommitter.appendUpsertIfMissing"
       )((store: StoreRef, event: PostUpsert) =>
@@ -144,6 +178,30 @@ export class StoreCommitter extends Context.Tag("@skygent/StoreCommitter")<
           .pipe(Effect.mapError(toStoreIoError(store.root)))
       );
 
+      const appendUpsertsIfMissing = Effect.fn(
+        "StoreCommitter.appendUpsertsIfMissing"
+      )((store: StoreRef, events: ReadonlyArray<PostUpsert>) => {
+        if (events.length === 0) {
+          return Effect.succeed([] as ReadonlyArray<Option.Option<EventLogEntry>>);
+        }
+        return storeDb
+          .withClient(store, (client) =>
+            client.withTransaction(
+              Effect.forEach(events, (event) =>
+                Effect.gen(function* () {
+                  const inserted = yield* insertPostIfMissing(client, event.post);
+                  if (!inserted) {
+                    return Option.none<EventLogEntry>();
+                  }
+                  const entry = yield* writer.appendWithClient(client, event);
+                  return Option.some(entry);
+                })
+              )
+            )
+          )
+          .pipe(Effect.mapError(toStoreIoError(store.root)));
+      });
+
       const appendDelete = Effect.fn("StoreCommitter.appendDelete")(
         (store: StoreRef, event: PostDelete) =>
           storeDb
@@ -160,7 +218,9 @@ export class StoreCommitter extends Context.Tag("@skygent/StoreCommitter")<
 
       return StoreCommitter.of({
         appendUpsert,
+        appendUpserts,
         appendUpsertIfMissing,
+        appendUpsertsIfMissing,
         appendDelete
       });
     })

package/src/services/store-manager.ts

@@ -63,7 +63,7 @@ import * as MigratorFileSystem from "@effect/sql/Migrator/FileSystem";
 import * as SqlClient from "@effect/sql/SqlClient";
 import * as SqlSchema from "@effect/sql/SqlSchema";
 import { SqliteClient } from "@effect/sql-sqlite-bun";
-import { StoreIoError } from "../domain/errors.js";
+import { StoreAlreadyExists, StoreIoError, StoreNotFound } from "../domain/errors.js";
 import { StoreConfig, StoreMetadata, StoreRef } from "../domain/store.js";
 import { StoreName, StorePath } from "../domain/primitives.js";
 import { AppConfigService } from "./app-config.js";
@@ -188,6 +188,23 @@ export class StoreManager extends Context.Tag("@skygent/StoreManager")<
     readonly deleteStore: (
       name: StoreName
     ) => Effect.Effect<void, StoreIoError>;
+
+    /**
+     * Renames a store in the catalog.
+     *
+     * This updates the store name and root path while preserving creation time.
+     *
+     * @param from - Existing store name
+     * @param to - New store name
+     * @returns Effect resolving to the updated StoreRef
+     * @throws {StoreNotFound} If the source store does not exist
+     * @throws {StoreAlreadyExists} If the target store already exists
+     * @throws {StoreIoError} When database operations fail
+     */
+    readonly renameStore: (
+      from: StoreName,
+      to: StoreName
+    ) => Effect.Effect<StoreRef, StoreNotFound | StoreAlreadyExists | StoreIoError>;
   }
 >() {
   /**
@@ -267,6 +284,21 @@ export class StoreManager extends Context.Tag("@skygent/StoreManager")<
           client`DELETE FROM stores WHERE name = ${name}`
       });
 
+      const renameStoreSql = SqlSchema.void({
+        Request: Schema.Struct({
+          oldName: StoreName,
+          newName: StoreName,
+          root: StorePath,
+          updatedAt: Schema.String
+        }),
+        execute: ({ oldName, newName, root, updatedAt }) =>
+          client`UPDATE stores
+            SET name = ${newName},
+                root = ${root},
+                updated_at = ${updatedAt}
+            WHERE name = ${oldName}`
+      });
+
       const createStore = Effect.fn("StoreManager.createStore")(
         (name: StoreName, config: StoreConfig) =>
           decodeStorePath(storeRootKey(name)).pipe(
@@ -337,6 +369,34 @@ export class StoreManager extends Context.Tag("@skygent/StoreManager")<
         );
       });
 
+      const renameStore = Effect.fn("StoreManager.renameStore")(
+        (from: StoreName, to: StoreName) =>
+          Effect.gen(function* () {
+            const newRoot = yield* decodeStorePath(storeRootKey(to));
+            const existing = yield* findStore(from).pipe(
+              Effect.mapError(toStoreIoError(manifestPath))
+            );
+            if (existing.length === 0) {
+              return yield* StoreNotFound.make({ name: from });
+            }
+            const conflict = yield* findStore(to).pipe(
+              Effect.mapError(toStoreIoError(manifestPath))
+            );
+            if (conflict.length > 0) {
+              return yield* StoreAlreadyExists.make({ name: to });
+            }
+            const nowMillis = yield* Clock.currentTimeMillis;
+            const now = new Date(nowMillis).toISOString();
+            yield* renameStoreSql({
+              oldName: from,
+              newName: to,
+              root: newRoot,
+              updatedAt: now
+            }).pipe(Effect.mapError(toStoreIoError(manifestPath)));
+            return StoreRef.make({ name: to, root: newRoot });
+          })
+      );
+
       const listStores = Effect.fn("StoreManager.listStores")(() =>
         Effect.gen(function* () {
           const rows = yield* listStoresSql(undefined);
@@ -352,7 +412,14 @@ export class StoreManager extends Context.Tag("@skygent/StoreManager")<
         }).pipe(Effect.mapError(toStoreIoError(manifestPath)))
       );
 
-      return StoreManager.of({ createStore, getStore, listStores, getConfig, deleteStore });
+      return StoreManager.of({
+        createStore,
+        getStore,
+        listStores,
+        getConfig,
+        deleteStore,
+        renameStore
+      });
     })
   ).pipe(Layer.provide(Reactivity.layer));
 }

package/src/services/store-renamer.ts

@@ -0,0 +1,286 @@
+import { FileSystem, Path } from "@effect/platform";
+import { Chunk, Context, Effect, Layer, Option, Ref, Schema } from "effect";
+import { StoreAlreadyExists, StoreIoError, StoreNotFound } from "../domain/errors.js";
+import { StoreLineage, StoreSource } from "../domain/derivation.js";
+import { StoreName, StorePath } from "../domain/primitives.js";
+import { StoreRef } from "../domain/store.js";
+import { AppConfigService } from "./app-config.js";
+import { LineageStore } from "./lineage-store.js";
+import { StoreDb } from "./store-db.js";
+import { StoreManager } from "./store-manager.js";
+
+type StoreRenameResult = {
+  readonly from: StoreName;
+  readonly to: StoreName;
+  readonly moved: boolean;
+  readonly lineagesUpdated: number;
+  readonly checkpointsUpdated: number;
+};
+
+type RenameState = {
+  readonly completed: boolean;
+  readonly dirRenamed: boolean;
+  readonly catalogUpdated: boolean;
+  readonly checkpointsUpdated: boolean;
+  readonly lineagesUpdated: boolean;
+};
+
+const storeRootKey = (name: StoreName) =>
+  Schema.decodeUnknownSync(StorePath)(`stores/${name}`);
+
+const toStoreIoError = (path: StorePath) => (cause: unknown) =>
+  StoreIoError.make({ path, cause });
+
+const toStoreRef = (metadata: { readonly name: StoreName; readonly root: StorePath }) =>
+  StoreRef.make({ name: metadata.name, root: metadata.root });
+
+const renameDirectory = (
+  fs: FileSystem.FileSystem,
+  path: Path.Path,
+  fromPath: string,
+  toPath: string
+) =>
+  Effect.gen(function* () {
+    if (fromPath === toPath) {
+      return;
+    }
+    const normalizedFrom = fromPath.toLowerCase();
+    const normalizedTo = toPath.toLowerCase();
+    if (normalizedFrom === normalizedTo) {
+      const tempName = `.rename-${Date.now()}`;
+      const tempPath = path.join(path.dirname(toPath), tempName);
+      yield* fs.rename(fromPath, tempPath);
+      yield* fs.rename(tempPath, toPath);
+      return;
+    }
+    yield* fs.rename(fromPath, toPath);
+  });
+
+const renameLineage = (
+  lineage: StoreLineage,
+  from: StoreName,
+  to: StoreName
+) => {
+  const nextStoreName = lineage.storeName === from ? to : lineage.storeName;
+  let changed = nextStoreName !== lineage.storeName;
+  const nextSources = lineage.sources.map((source) => {
+    if (source.storeName !== from) {
+      return source;
+    }
+    changed = true;
+    return StoreSource.make({ ...source, storeName: to });
+  });
+  if (!changed) {
+    return Option.none<StoreLineage>();
+  }
+  return Option.some(
+    StoreLineage.make({
+      ...lineage,
+      storeName: nextStoreName,
+      sources: nextSources
+    })
+  );
+};
+
+export class StoreRenamer extends Context.Tag("@skygent/StoreRenamer")<
+  StoreRenamer,
+  {
+    readonly rename: (
+      from: StoreName,
+      to: StoreName
+    ) => Effect.Effect<StoreRenameResult, StoreNotFound | StoreAlreadyExists | StoreIoError>;
+  }
+>() {
+  static readonly layer = Layer.effect(
+    StoreRenamer,
+    Effect.gen(function* () {
+      const manager = yield* StoreManager;
+      const storeDb = yield* StoreDb;
+      const lineageStore = yield* LineageStore;
+      const appConfig = yield* AppConfigService;
+      const fs = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+
+      const updateLineages = (
+        from: StoreName,
+        to: StoreName,
+        storeNames: ReadonlyArray<StoreName>
+      ) =>
+        Effect.forEach(
+          storeNames,
+          (storeName) =>
+            lineageStore.get(storeName).pipe(
+              Effect.flatMap(
+                Option.match({
+                  onNone: () => Effect.succeed(0),
+                  onSome: (lineage) =>
+                    Option.match(renameLineage(lineage, from, to), {
+                      onNone: () => Effect.succeed(0),
+                      onSome: (updated) =>
+                        Effect.gen(function* () {
+                          yield* lineageStore.save(updated);
+                          if (lineage.storeName === from) {
+                            yield* lineageStore.remove(from);
+                          }
+                          return 1;
+                        })
+                    })
+                })
+              )
+            ),
+          { discard: false }
+        ).pipe(Effect.map((updates) => updates.reduce((sum, value) => sum + value, 0)));
+
+      const updateDerivationCheckpoints = (
+        from: StoreName,
+        to: StoreName,
+        stores: ReadonlyArray<StoreRef>
+      ) =>
+        Effect.forEach(
+          stores,
+          (store) =>
+            storeDb.withClient(store, (client) =>
+              client`UPDATE derivation_checkpoints
+                SET view_name = CASE WHEN view_name = ${from} THEN ${to} ELSE view_name END,
+                    source_store = CASE WHEN source_store = ${from} THEN ${to} ELSE source_store END,
+                    target_store = CASE WHEN target_store = ${from} THEN ${to} ELSE target_store END
+                WHERE view_name = ${from}
+                   OR source_store = ${from}
+                   OR target_store = ${from}`.pipe(Effect.as(1))
+            ).pipe(Effect.mapError(toStoreIoError(store.root))),
+          { discard: false }
+        ).pipe(Effect.map((updates) => updates.reduce((sum, value) => sum + value, 0)));
+
+      const rename = Effect.fn("StoreRenamer.rename")(
+        (from: StoreName, to: StoreName) =>
+          Effect.gen(function* () {
+            const storeOption = yield* manager.getStore(from);
+            if (Option.isNone(storeOption)) {
+              return yield* StoreNotFound.make({ name: from });
+            }
+            const targetOption = yield* manager.getStore(to);
+            if (Option.isSome(targetOption)) {
+              return yield* StoreAlreadyExists.make({ name: to });
+            }
+            const store = storeOption.value;
+            const newRoot = storeRootKey(to);
+            const fromPath = path.join(appConfig.storeRoot, store.root);
+            const toPath = path.join(appConfig.storeRoot, newRoot);
+            const fromExists = yield* fs
+              .exists(fromPath)
+              .pipe(Effect.mapError(toStoreIoError(store.root)));
+            const toExists = yield* fs
+              .exists(toPath)
+              .pipe(Effect.mapError(toStoreIoError(newRoot)));
+            if (toExists) {
+              return yield* StoreAlreadyExists.make({ name: to });
+            }
+
+            const storesBefore = yield* manager.listStores();
+            const storeNamesBefore = Chunk.toReadonlyArray(storesBefore).map(
+              (entry) => entry.name
+            );
+
+            const state = yield* Ref.make<RenameState>({
+              completed: false,
+              dirRenamed: false,
+              catalogUpdated: false,
+              checkpointsUpdated: false,
+              lineagesUpdated: false
+            });
+
+            const rollback = (status: RenameState) =>
+              status.completed
+                ? Effect.void
+                : Effect.gen(function* () {
+                    if (status.lineagesUpdated) {
+                      const stores = yield* manager.listStores();
+                      const storeNames = Chunk.toReadonlyArray(stores).map(
+                        (entry) => entry.name
+                      );
+                      yield* updateLineages(to, from, storeNames).pipe(
+                        Effect.catchAll(() => Effect.void)
+                      );
+                    }
+                    if (status.checkpointsUpdated) {
+                      const stores = yield* manager.listStores();
+                      const storeRefs = Chunk.toReadonlyArray(stores).map(toStoreRef);
+                      yield* updateDerivationCheckpoints(to, from, storeRefs).pipe(
+                        Effect.catchAll(() => Effect.void)
+                      );
+                    }
+                    if (status.dirRenamed) {
+                      yield* storeDb.removeClient(to);
+                      yield* renameDirectory(fs, path, toPath, fromPath).pipe(
+                        Effect.catchAll(() => Effect.void)
+                      );
+                    }
+                    if (status.catalogUpdated) {
+                      yield* manager.renameStore(to, from).pipe(
+                        Effect.catchAll(() => Effect.void)
+                      );
+                    }
+                  });
+
+            const program = Effect.gen(function* () {
+              yield* storeDb.removeClient(from);
+
+              if (fromExists) {
+                yield* renameDirectory(fs, path, fromPath, toPath).pipe(
+                  Effect.mapError(toStoreIoError(store.root))
+                );
+                yield* Ref.update(state, (current) => ({ ...current, dirRenamed: true }));
+              }
+
+              yield* manager.renameStore(from, to);
+              yield* Ref.update(state, (current) => ({
+                ...current,
+                catalogUpdated: true
+              }));
+
+              const storesAfter = yield* manager.listStores();
+              const storeRefsAfter = Chunk.toReadonlyArray(storesAfter).map(toStoreRef);
+
+              const checkpointsUpdated = yield* updateDerivationCheckpoints(
+                from,
+                to,
+                storeRefsAfter
+              );
+              yield* Ref.update(state, (current) => ({
+                ...current,
+                checkpointsUpdated: true
+              }));
+
+              const lineagesUpdated = yield* updateLineages(from, to, storeNamesBefore);
+              yield* Ref.update(state, (current) => ({
+                ...current,
+                lineagesUpdated: true
+              }));
+
+              yield* Ref.update(state, (current) => ({ ...current, completed: true }));
+
+              return {
+                from,
+                to,
+                moved: fromExists,
+                lineagesUpdated,
+                checkpointsUpdated
+              } satisfies StoreRenameResult;
+            });
+
+            return yield* program.pipe(
+              Effect.ensuring(
+                Ref.get(state).pipe(
+                  Effect.flatMap(rollback),
+                  Effect.catchAll(() => Effect.void),
+                  Effect.uninterruptible
+                )
+              )
+            );
+          })
+      );
+
+      return StoreRenamer.of({ rename });
+    })
+  );
+}