@powerhousedao/reactor-local 1.3.4 → 1.4.0

package/dist/cli.js

@@ -1,5 +1,5 @@
 #! /usr/bin/env node
-import { startServer } from './chunk-TDNXJJIZ.js';
+import { startServer } from './chunk-N5JF3C3S.js';
 import { Command } from 'commander';
 
 var reactorLocalAction = (options) => {

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/index.js

@@ -1,4 +1,4 @@
-import { startServer } from './chunk-TDNXJJIZ.js';
+import { startServer } from './chunk-N5JF3C3S.js';
 
 // src/index.ts
 startServer().catch((error) => {

package/dist/indexer.d.ts

@@ -0,0 +1,9 @@
+import { IDocumentDriveServer } from 'document-drive/server';
+
+type DocumentIndexerOptions = {
+    reactor: IDocumentDriveServer;
+    path: string;
+};
+declare function addDocumentIndexer(options: DocumentIndexerOptions): Promise<void>;
+
+export { type DocumentIndexerOptions, addDocumentIndexer };

package/dist/indexer.js

@@ -0,0 +1,24 @@
+import { drizzle } from 'drizzle-orm/connect';
+import { setAdditionalContextFields, registerInternalListener, addSubgraph, createSchema } from '@powerhousedao/reactor-api';
+import * as searchListener from '@powerhousedao/general-document-indexer';
+
+// src/indexer.ts
+async function addDocumentIndexer(options2) {
+  const db = await drizzle("pglite", options2.path);
+  setAdditionalContextFields({ db });
+  await registerInternalListener({
+    name: "search",
+    options: searchListener.options,
+    transmit: (strands) => searchListener.transmit(strands, db)
+  });
+  await addSubgraph({
+    getSchema: () => createSchema(
+      options2.reactor,
+      searchListener.resolvers,
+      searchListener.typeDefs
+    ),
+    name: "search/:drive"
+  });
+}
+
+export { addDocumentIndexer };

package/dist/server.d.ts

@@ -1,3 +1,253 @@
-declare const startServer: () => Promise<void>;
+import { Trigger, PullResponderTriggerData, DocumentDriveState, DocumentDriveLocalState, ListenerFilter, ListenerCallInfo, DocumentDriveDocument, DocumentDriveAction } from 'document-model-libs/document-drive';
+import { Document, OperationScope, Operation, State, ActionContext, DocumentModel, Action, BaseAction, CreateChildDocumentInput, ReducerOptions, Signal } from 'document-model/document';
+import { Unsubscribe } from 'nanoevents';
 
-export { startServer };
+type StrandUpdateSource = {
+    type: "local";
+} | {
+    type: "trigger";
+    trigger: Trigger;
+};
+interface ITransmitter {
+    transmit?(strands: StrandUpdate[], source: StrandUpdateSource): Promise<ListenerRevision[]>;
+    disconnect?(): Promise<void>;
+}
+type PullResponderTrigger = Omit<Trigger, "data" | "type"> & {
+    data: PullResponderTriggerData;
+    type: "PullResponder";
+};
+
+interface IReceiver {
+    transmit: (strands: InternalTransmitterUpdate[]) => Promise<void>;
+    disconnect: () => Promise<void>;
+}
+type InternalTransmitterUpdate<T extends Document = Document, S extends OperationScope = OperationScope> = {
+    driveId: string;
+    documentId: string;
+    scope: S;
+    branch: string;
+    operations: OperationUpdate[];
+    state: T["state"][S];
+};
+interface IInternalTransmitter extends ITransmitter {
+    setReceiver(receiver: IReceiver): void;
+}
+declare class InternalTransmitter implements ITransmitter {
+    private drive;
+    private listener;
+    private receiver;
+    constructor(listener: Listener, drive: IBaseDocumentDriveServer);
+    transmit(strands: StrandUpdate[]): Promise<ListenerRevision[]>;
+    setReceiver(receiver: IReceiver): void;
+    disconnect(): Promise<void>;
+}
+
+declare class OperationError extends Error {
+    status: ErrorStatus;
+    operation: Operation | undefined;
+    constructor(status: ErrorStatus, operation?: Operation, message?: string, cause?: unknown);
+}
+declare class SynchronizationUnitNotFoundError extends Error {
+    syncUnitId: string;
+    constructor(message: string, syncUnitId: string);
+}
+
+type DriveInfo = {
+    id: string;
+    name: string;
+    slug: string;
+    icon?: string;
+};
+
+type DriveInput = State<Omit<DocumentDriveState, "__typename" | "id" | "nodes"> & {
+    id?: string;
+}, DocumentDriveLocalState>;
+type RemoteDriveAccessLevel = "READ" | "WRITE";
+type RemoteDriveOptions = DocumentDriveLocalState & {
+    pullFilter?: ListenerFilter;
+    pullInterval?: number;
+    expectedDriveInfo?: DriveInfo;
+    accessLevel?: RemoteDriveAccessLevel;
+};
+type CreateDocumentInput = CreateChildDocumentInput;
+type SignalResult = {
+    signal: Signal;
+    result: unknown;
+};
+type IOperationResult<T extends Document = Document> = {
+    status: UpdateStatus;
+    error?: OperationError;
+    operations: Operation[];
+    document: T | undefined;
+    signals: SignalResult[];
+};
+type SynchronizationUnit = {
+    syncId: string;
+    driveId: string;
+    documentId: string;
+    documentType: string;
+    scope: string;
+    branch: string;
+    lastUpdated: string;
+    revision: number;
+};
+type SynchronizationUnitQuery = Omit<SynchronizationUnit, "revision" | "lastUpdated">;
+type Listener = {
+    driveId: string;
+    listenerId: string;
+    label?: string;
+    block: boolean;
+    system: boolean;
+    filter: ListenerFilter;
+    callInfo?: ListenerCallInfo;
+};
+type ListenerRevision = {
+    driveId: string;
+    documentId: string;
+    scope: string;
+    branch: string;
+    status: UpdateStatus;
+    revision: number;
+    error?: string;
+};
+type UpdateStatus = "SUCCESS" | "CONFLICT" | "MISSING" | "ERROR";
+type ErrorStatus = Exclude<UpdateStatus, "SUCCESS">;
+type OperationUpdate = {
+    timestamp: string;
+    index: number;
+    skip: number;
+    type: string;
+    input: object;
+    hash: string;
+    context?: ActionContext;
+    id?: string;
+};
+type StrandUpdate = {
+    driveId: string;
+    documentId: string;
+    scope: OperationScope;
+    branch: string;
+    operations: OperationUpdate[];
+};
+type SyncStatus = "INITIAL_SYNC" | "SYNCING" | UpdateStatus;
+type PullSyncStatus = SyncStatus;
+type PushSyncStatus = SyncStatus;
+type SyncUnitStatusObject = {
+    push?: PushSyncStatus;
+    pull?: PullSyncStatus;
+};
+type AddRemoteDriveStatus = "SUCCESS" | "ERROR" | "PENDING" | "ADDING" | "ALREADY_ADDED";
+interface DriveEvents {
+    syncStatus: (driveId: string, status: SyncStatus, error?: Error, syncUnitStatus?: SyncUnitStatusObject) => void;
+    defaultRemoteDrive: (status: AddRemoteDriveStatus, defaultDrives: Map<string, DefaultRemoteDriveInfo>, driveInput: DefaultRemoteDriveInput, driveId?: string, driveName?: string, error?: Error) => void;
+    strandUpdate: (update: StrandUpdate) => void;
+    clientStrandsError: (driveId: string, trigger: Trigger, status: number, errorMessage: string) => void;
+    documentModels: (documentModels: DocumentModel[]) => void;
+    driveAdded: (drive: DocumentDriveDocument) => void;
+    driveDeleted: (driveId: string) => void;
+}
+type PartialRecord<K extends keyof any, T> = {
+    [P in K]?: T;
+};
+type RevisionsFilter = PartialRecord<OperationScope, number>;
+type GetDocumentOptions = ReducerOptions & {
+    revisions?: RevisionsFilter;
+    checkHashes?: boolean;
+};
+type AddOperationOptions = {
+    forceSync?: boolean;
+    source: StrandUpdateSource;
+};
+type DefaultRemoteDriveInput = {
+    url: string;
+    options: RemoteDriveOptions;
+};
+type DefaultRemoteDriveInfo = DefaultRemoteDriveInput & {
+    status: AddRemoteDriveStatus;
+    metadata?: DriveInfo;
+};
+type GetStrandsOptions = {
+    limit?: number;
+    since?: string;
+    fromRevision?: number;
+};
+declare abstract class AbstractDocumentDriveServer {
+    /** Public methods **/
+    abstract initialize(): Promise<Error[] | null>;
+    abstract setDocumentModels(models: DocumentModel[]): void;
+    abstract getDrives(): Promise<string[]>;
+    abstract addDrive(drive: DriveInput): Promise<DocumentDriveDocument>;
+    abstract addRemoteDrive(url: string, options: RemoteDriveOptions): Promise<DocumentDriveDocument>;
+    abstract deleteDrive(id: string): Promise<void>;
+    abstract getDrive(id: string, options?: GetDocumentOptions): Promise<DocumentDriveDocument>;
+    abstract getDriveBySlug(slug: string): Promise<DocumentDriveDocument>;
+    abstract getDocuments(drive: string): Promise<string[]>;
+    abstract getDocument(drive: string, id: string, options?: GetDocumentOptions): Promise<Document>;
+    abstract addOperation(drive: string, id: string, operation: Operation, options?: AddOperationOptions): Promise<IOperationResult>;
+    abstract addOperations(drive: string, id: string, operations: Operation[], options?: AddOperationOptions): Promise<IOperationResult>;
+    abstract queueOperation(drive: string, id: string, operation: Operation, options?: AddOperationOptions): Promise<IOperationResult>;
+    abstract queueOperations(drive: string, id: string, operations: Operation[], options?: AddOperationOptions): Promise<IOperationResult>;
+    abstract queueAction(drive: string, id: string, action: Action, options?: AddOperationOptions): Promise<IOperationResult>;
+    abstract queueActions(drive: string, id: string, actions: Action[], options?: AddOperationOptions): Promise<IOperationResult>;
+    abstract addDriveOperation(drive: string, operation: Operation<DocumentDriveAction | BaseAction>, options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
+    abstract addDriveOperations(drive: string, operations: Operation<DocumentDriveAction | BaseAction>[], options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
+    abstract queueDriveOperation(drive: string, operation: Operation<DocumentDriveAction | BaseAction>, options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
+    abstract queueDriveOperations(drive: string, operations: Operation<DocumentDriveAction | BaseAction>[], options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
+    abstract queueDriveAction(drive: string, action: DocumentDriveAction | BaseAction, options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
+    abstract queueDriveActions(drive: string, actions: Array<DocumentDriveAction | BaseAction>, options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
+    abstract addAction(drive: string, id: string, action: Action, options?: AddOperationOptions): Promise<IOperationResult>;
+    abstract addActions(drive: string, id: string, actions: Action[], options?: AddOperationOptions): Promise<IOperationResult>;
+    abstract addDriveAction(drive: string, action: DocumentDriveAction | BaseAction, options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
+    abstract addDriveActions(drive: string, actions: (DocumentDriveAction | BaseAction)[], options?: AddOperationOptions): Promise<IOperationResult<DocumentDriveDocument>>;
+    abstract getSyncStatus(syncUnitId: string): SyncStatus | SynchronizationUnitNotFoundError;
+    abstract addInternalListener(driveId: string, receiver: IReceiver, options: {
+        listenerId: string;
+        label: string;
+        block: boolean;
+        filter: ListenerFilter;
+    }): Promise<IInternalTransmitter>;
+    /** Synchronization methods */
+    abstract getSynchronizationUnits(driveId: string, documentId?: string[], scope?: string[], branch?: string[], documentType?: string[], loadedDrive?: DocumentDriveDocument): Promise<SynchronizationUnit[]>;
+    abstract getSynchronizationUnit(driveId: string, syncId: string, loadedDrive?: DocumentDriveDocument): Promise<SynchronizationUnit | undefined>;
+    abstract getSynchronizationUnitsIds(driveId: string, documentId?: string[], scope?: string[], branch?: string[], documentType?: string[]): Promise<SynchronizationUnitQuery[]>;
+    abstract getOperationData(driveId: string, syncId: string, filter: GetStrandsOptions, loadedDrive?: DocumentDriveDocument): Promise<OperationUpdate[]>;
+    /** Internal methods **/
+    protected abstract createDocument(drive: string, document: CreateDocumentInput): Promise<Document>;
+    protected abstract deleteDocument(drive: string, id: string): Promise<void>;
+    protected abstract getDocumentModel(documentType: string): DocumentModel;
+    abstract getDocumentModels(): DocumentModel[];
+    /** Event methods **/
+    protected abstract emit<K extends keyof DriveEvents>(event: K, ...args: Parameters<DriveEvents[K]>): void;
+    abstract on<K extends keyof DriveEvents>(event: K, cb: DriveEvents[K]): Unsubscribe;
+    abstract getTransmitter(driveId: string, listenerId: string): Promise<ITransmitter | undefined>;
+    abstract clearStorage(): Promise<void>;
+    abstract registerPullResponderTrigger(id: string, url: string, options: Pick<RemoteDriveOptions, "pullFilter" | "pullInterval">): Promise<PullResponderTrigger>;
+}
+type PublicKeys<T> = {
+    [K in keyof T]: T extends {
+        [P in K]: T[K];
+    } ? K : never;
+}[keyof T];
+type PublicPart<T> = Pick<T, PublicKeys<T>>;
+type IBaseDocumentDriveServer = PublicPart<AbstractDocumentDriveServer>;
+
+type StartServerOptions = {
+    connect?: {
+        port?: string | number;
+    };
+    reactor?: {
+        storagePath?: string;
+        drive?: DriveInput;
+    };
+};
+declare const startServer: (options?: StartServerOptions) => Promise<{
+    getDocumentPath: (driveId: string, documentId: string) => string;
+    addListener: (driveId: string, receiver: IReceiver, options: {
+        listenerId: string;
+        label: string;
+        block: boolean;
+        filter: ListenerFilter;
+    }) => Promise<InternalTransmitter>;
+}>;
+
+export { type StartServerOptions, startServer };

package/dist/server.js

@@ -1 +1 @@
-export { startServer } from './chunk-TDNXJJIZ.js';
+export { startServer } from './chunk-N5JF3C3S.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@powerhousedao/reactor-local",
   "type": "module",
-  "version": "1.3.4",
+  "version": "1.4.0",
   "main": "dist/server.js",
   "bin": {
     "reactor-local": "dist/cli.js"
@@ -16,19 +16,25 @@
     "@apollo/subgraph": "^2.9.2",
     "@electric-sql/pglite": "^0.2.12",
     "@libsql/client": "^0.14.0",
-    "@powerhousedao/general-document-indexer": "^1.3.4",
-    "@powerhousedao/reactor-api": "^1.3.4",
-    "@powerhousedao/scalars": "^1.8.0",
+    "@powerhousedao/general-document-indexer": "^1.3.5",
+    "@powerhousedao/reactor-api": "^1.4.0",
+    "@powerhousedao/scalars": "^1.9.0",
+    "change-case": "^5.4.4",
     "commander": "^12.1.0",
-    "document-drive": "^1.3.4",
     "document-model": "^2.6.0",
-    "document-model-libs": "^1.110.0",
+    "document-model-libs": "^1.110.1",
     "dotenv": "^16.4.5",
     "drizzle-kit": "^0.25.0",
     "drizzle-orm": "^0.34.1",
     "express": "^4.21.0",
+    "graphql": "^16.8.1",
+    "graphql-request": "^6.1.0",
+    "json-stringify-deterministic": "^1.0.12",
     "ms": "^2.1.3",
+    "nanoevents": "^9.0.0",
     "pg": "^8.13.0",
+    "sanitize-filename": "^1.6.3",
+    "uuid": "^11.0.2",
     "vite-node": "^2.1.2"
   },
   "devDependencies": {
@@ -38,9 +44,14 @@
     "@types/ms": "^0.7.34",
     "@types/node": "^22.7.5",
     "@types/pg": "^8.11.10",
+    "document-drive": "^1.4.0",
     "postcss": "^8.4.47",
     "tsup": "^8.3.0",
-    "typescript": "^5.6.2"
+    "typescript": "^5.6.2",
+    "@powerhousedao/scalars": "^1.9.0"
+  },
+  "peerDependencies": {
+    "@powerhousedao/scalars": "^1.9.0"
   },
   "scripts": {
     "start": "vite-node src/index.ts",

package/src/cli.ts

@@ -1,6 +1,6 @@
 #! /usr/bin/env node
 import { Command } from "commander";
-import { startServer } from "./server";
+import { startServer } from "./server.js";
 
 type ReactorLocalOptions = {
   port?: string;

package/src/index.ts

@@ -1,4 +1,4 @@
-import { startServer } from "./server";
+import { startServer } from "./server.js";
 
 startServer().catch((error: unknown) => {
   throw error;

package/src/indexer.ts

@@ -0,0 +1,38 @@
+import { drizzle } from "drizzle-orm/connect";
+import { type GraphQLResolverMap } from "@apollo/subgraph/dist/schema-helper";
+import {
+  addSubgraph,
+  createSchema,
+  registerInternalListener,
+  setAdditionalContextFields,
+} from "@powerhousedao/reactor-api";
+import * as searchListener from "@powerhousedao/general-document-indexer";
+import { IDocumentDriveServer } from "document-drive/server";
+
+export type DocumentIndexerOptions = {
+  reactor: IDocumentDriveServer;
+  path: string;
+};
+
+export async function addDocumentIndexer(options: DocumentIndexerOptions) {
+  const db = await drizzle("pglite", options.path);
+  setAdditionalContextFields({ db });
+
+  // register general document indexer listener
+  await registerInternalListener({
+    name: "search",
+    options: searchListener.options,
+    transmit: (strands) => searchListener.transmit(strands, db),
+  });
+
+  // add general document indexer subgraph
+  await addSubgraph({
+    getSchema: () =>
+      createSchema(
+        options.reactor,
+        searchListener.resolvers as GraphQLResolverMap,
+        searchListener.typeDefs,
+      ),
+    name: "search/:drive",
+  });
+}

package/src/server.ts

@@ -1,52 +1,64 @@
-import { GraphQLResolverMap } from "@apollo/subgraph/dist/schema-helper";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import dotenv from "dotenv";
+import { startAPI } from "@powerhousedao/reactor-api";
 import {
-  addSubgraph,
-  createSchema,
-  registerInternalListener,
-  setAdditionalContextFields,
-  startAPI,
-} from "@powerhousedao/reactor-api";
-import { DocumentDriveServer, DriveAlreadyExistsError } from "document-drive";
+  DocumentDriveServer,
+  DriveAlreadyExistsError,
+  DriveInput,
+  IReceiver,
+} from "document-drive";
 import { FilesystemStorage } from "document-drive/storage/filesystem";
 import * as DocumentModelsLibs from "document-model-libs/document-models";
 import { DocumentModel } from "document-model/document";
 import { module as DocumentModelLib } from "document-model/document-model";
-import dotenv from "dotenv";
-import { drizzle } from "drizzle-orm/connect";
-import path from "path";
-import * as searchListener from "@powerhousedao/general-document-indexer";
-dotenv.config();
+import { ListenerFilter } from "document-model-libs/document-drive";
 
-// start document drive server with all available document models & filesystem storage
-const driveServer = new DocumentDriveServer(
-  [DocumentModelLib, ...Object.values(DocumentModelsLibs)] as DocumentModel[],
-  new FilesystemStorage(path.join(__dirname, "../file-storage")),
-);
+const dirname =
+  import.meta.dirname || path.dirname(fileURLToPath(import.meta.url));
 
-// Start GraphQL API
-const serverPort = process.env.PORT ? Number(process.env.PORT) : 4001;
+dotenv.config();
 
-const startServer = async () => {
-  const db = await drizzle("pglite", "./dev.db");
+export type StartServerOptions = {
+  connect?: {
+    port?: string | number;
+  };
+  reactor?: {
+    storagePath?: string;
+    drive?: DriveInput;
+  };
+};
+
+const startServer = async (options?: StartServerOptions) => {
+  const serverPort = Number(options?.connect?.port ?? process.env.PORT ?? 4001);
+  const storagePath =
+    options?.reactor?.storagePath ?? path.join(dirname, "./file-storage");
+  const drive = options?.reactor?.drive ?? {
+    global: {
+      id: "powerhouse",
+      name: "Powerhouse",
+      icon: "https://ipfs.io/ipfs/QmcaTDBYn8X2psGaXe7iQ6qd8q6oqHLgxvMX9yXf7f9uP7",
+      slug: "powerhouse",
+    },
+    local: {
+      availableOffline: true,
+      listeners: [],
+      sharingType: "public",
+      triggers: [],
+    },
+  };
+  // start document drive server with all available document models & filesystem storage
+  const driveServer = new DocumentDriveServer(
+    [DocumentModelLib, ...Object.values(DocumentModelsLibs)] as DocumentModel[],
+    new FilesystemStorage(storagePath),
+  );
 
   // init drive server
   await driveServer.initialize();
+
   try {
     // add default drive
-    await driveServer.addDrive({
-      global: {
-        id: "powerhouse",
-        name: "Powerhouse",
-        icon: "powerhouse",
-        slug: "powerhouse",
-      },
-      local: {
-        availableOffline: true,
-        listeners: [],
-        sharingType: "public",
-        triggers: [],
-      },
-    });
+    await driveServer.addDrive(drive);
   } catch (e) {
     if (e instanceof DriveAlreadyExistsError) {
       console.info("Default drive already exists. Skipping...");
@@ -60,29 +72,25 @@ const startServer = async () => {
     await startAPI(driveServer, {
       port: serverPort,
     });
-
-    setAdditionalContextFields({ db });
-
-    // register general document indexer listener
-    await registerInternalListener({
-      name: "search",
-      options: searchListener.options,
-      transmit: (strands) => searchListener.transmit(strands, db),
-    });
-
-    // add general document indexer subgraph
-    await addSubgraph({
-      getSchema: () =>
-        createSchema(
-          driveServer,
-          searchListener.resolvers as GraphQLResolverMap,
-          searchListener.typeDefs,
-        ),
-      name: "search/:drive",
-    });
   } catch (e) {
     console.error("App crashed", e);
   }
+
+  return {
+    getDocumentPath: (driveId: string, documentId: string): string => {
+      return path.join(storagePath, driveId, `${documentId}.json`);
+    },
+    addListener: (
+      driveId: string,
+      receiver: IReceiver,
+      options: {
+        listenerId: string;
+        label: string;
+        block: boolean;
+        filter: ListenerFilter;
+      },
+    ) => driveServer.addInternalListener(driveId, receiver, options),
+  };
 };
 
 export { startServer };

package/tsconfig.json

@@ -2,7 +2,6 @@
   "compilerOptions": {
     "esModuleInterop": true,
     "skipLibCheck": true,
-    "target": "ESNext",
     "allowJs": true,
     "resolveJsonModule": true,
     "moduleDetection": "force",
@@ -16,7 +15,10 @@
     "module": "ESNext",
     "noEmit": true,
     "lib": ["ESNext"],
-    "types": ["node", "./types.d.ts"]
+    "types": ["node", "./types.d.ts"],
+    "paths": {
+      "document-drive": ["../document-drive/src/index.ts"]
+    }
   },
   "include": ["./"]
 }

package/tsup.config.ts

@@ -1,27 +1,5 @@
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import { createRequire } from "node:module";
 import { defineConfig } from "tsup";
 
-const require = createRequire(import.meta.url);
-
-function getDependencies(packageName: string) {
-  try {
-    const dependencyPath = require.resolve(packageName);
-    const packagePath = join(dependencyPath, "../../package.json");
-    const packageJson = JSON.parse(readFileSync(packagePath, "utf8")) as {
-      dependencies?: Record<string, string>;
-      peerDependencies?: Record<string, string>;
-    };
-    return Object.keys(packageJson.dependencies || {}).concat(
-      Object.keys(packageJson.peerDependencies || {}),
-    );
-  } catch (error) {
-    console.error(`Failed to load dependencies for ${packageName}:`, error);
-    return [];
-  }
-}
-
 export default defineConfig({
   entry: ["src/**/*.ts"],
   splitting: true,
@@ -31,15 +9,9 @@ export default defineConfig({
   treeshake: true,
   bundle: true,
   platform: "node",
-  target: "node22",
+  target: "node20",
   noExternal: ["document-drive"],
-  external: getDependencies("document-drive"),
   shims: true,
   cjsInterop: true,
-  dts: {
-    entry: {
-      server: "src/server.ts",
-      cli: "src/cli.ts",
-    },
-  },
+  dts: true,
 });

package/types.ts

@@ -1,9 +1,9 @@
-import { BaseDocumentDriveServer } from "document-drive";
+import { IDocumentDriveServer } from "document-drive";
 import { DrizzleD1Database } from "drizzle-orm/d1";
 import { IncomingHttpHeaders } from "http";
 
 export type Context = {
-  driveServer: BaseDocumentDriveServer;
+  driveServer: IDocumentDriveServer;
   driveId?: string;
   headers: IncomingHttpHeaders;
   db: Omit<DrizzleD1Database, "run" | "batch" | "all" | "get" | "values">;