@kubun/connector 0.6.0 → 0.8.0

package/lib/cluster-utils.d.ts

@@ -0,0 +1,6 @@
+import type { ClustersRecord } from '@kubun/protocol';
+/**
+ * Resolve a model name to its content-addressed model ID across clusters.
+ * Use this in providers to tag EntityBatch.modelID at module level.
+ */
+export declare function resolveModelID(clusters: ClustersRecord, modelName: string): string;

package/lib/cluster-utils.js

@@ -0,0 +1 @@
+export function resolveModelID(e,o){for(let r of Object.values(e)){let e=r.models.findIndex(e=>e.name===o);if(-1!==e){for(let[o,t]of Object.entries(r.record))if(t===e)return o}}throw Error(`Model "${o}" not found in any cluster`)}

package/lib/index.d.ts

@@ -1,8 +1,4 @@
-export { type ConnectorActivatedEvent, type ConnectorDeactivatedEvent, ConnectorManager, type ConnectorManagerEvents, type ConnectorManagerParams, } from './manager.js';
+export { resolveModelID } from './cluster-utils.js';
+export { connectorClusters, connectorModelIDs } from './models/cluster.js';
 export { externalEntityDefinition } from './models/external-entity.js';
-export { createOAuthRoutes, type OAuthRoutesParams, type StateStore } from './oauth/routes.js';
-export type { Credential, CredentialProvider, OAuthProviderDefinition, OAuthState, TokenResponse, } from './oauth/types.js';
-export { type ConnectorActionParams, type ConnectorActionResult, type ConnectorAuthCompleteParams, type ConnectorAuthCompleteResult, type ConnectorAuthURLParams, type ConnectorAuthURLResult, type ConnectorProtocol, type ConnectorPushCompleteParams, type ConnectorPushCompleteResult, type ConnectorPushParams, type ConnectorPushResult, type ConnectorStatusParams, type ConnectorStatusResult, type ConnectorSyncParams, type ConnectorSyncReceive, type ConnectorSyncResult, connectorProtocol, } from './protocol.js';
-export { ConnectorRegistry } from './registry.js';
-export { computeEffectiveBoundary, isWithinBoundary, parseDuration, } from './sync/boundary.js';
-export type { ActionDefinition, ActionResult, ClientDataProvider, ClientProviderFactory, ConnectorAuth, ConnectorDefinition, DataProvider, DeviceConnectorAuth, DevicePermission, EntityBatch, EntityRecord, FetchChangesParams, FetchParams, OAuthConnectorAuth, ServerDataProvider, ServerProviderFactory, SyncBoundary, SyncCompleteEvent, SyncErrorEvent, SyncEvent, SyncProgressEvent, UserSyncPreferences, WebhookParams, WebhookRegistration, } from './types.js';
+export type { ActionDefinition, ActionHandler, ActionHandlerFactory, ActionResult, ClientDataProvider, ClientProviderFactory, ConnectorAuth, ConnectorDefinition, ConnectorSyncEventPayload, Credential, CredentialProvider, DataProvider, DeviceConnectorAuth, DevicePermission, EntityBatch, EntityRecord, FetchChangesParams, FetchParams, OAuthConnectorAuth, OAuthProviderDefinition, OAuthState, ServerDataProvider, ServerProviderFactory, SyncBoundary, SyncCompleteEvent, SyncErrorEvent, SyncEvent, SyncProgressEvent, SyncState, SyncStateEntry, SyncStateStore, SyncStatus, TokenResponse, UserSyncPreferences, WebhookParams, WebhookRegistration, } from './types.js';

package/lib/index.js

@@ -1 +1 @@
-export{ConnectorManager}from"./manager.js";export{externalEntityDefinition}from"./models/external-entity.js";export{createOAuthRoutes}from"./oauth/routes.js";export{connectorProtocol}from"./protocol.js";export{ConnectorRegistry}from"./registry.js";export{computeEffectiveBoundary,isWithinBoundary,parseDuration}from"./sync/boundary.js";
+export{resolveModelID}from"./cluster-utils.js";export{connectorClusters,connectorModelIDs}from"./models/cluster.js";export{externalEntityDefinition}from"./models/external-entity.js";

package/lib/models/cluster.d.ts

@@ -0,0 +1,4 @@
+export declare const connectorClusters: import("@kubun/protocol").ClustersRecord;
+export declare const connectorModelIDs: {
+    readonly ExternalEntity: string;
+};

package/lib/models/cluster.js

@@ -0,0 +1 @@
+import{GraphBuilder as t,GraphModel as e}from"@kubun/protocol";import{externalEntityDefinition as o}from"./external-entity.js";let r=new t;r.add(o);export const connectorClusters=r.build();let n=e.fromClusters({clusters:connectorClusters});export const connectorModelIDs={ExternalEntity:n.aliases.ExternalEntity};

package/lib/models/external-entity.d.ts

@@ -1,4 +1,3 @@
-import type { DocumentModelInput } from '@kubun/protocol';
 /**
  * ExternalEntity is the base interface for documents synced from external services.
  *
@@ -8,4 +7,43 @@ import type { DocumentModelInput } from '@kubun/protocol';
  * - sourceURL: Optional URL back to the entity in the source service
  * - lastSyncedAt: Timestamp of when this entity was last synced
  */
-export declare const externalEntityDefinition: DocumentModelInput;
+export declare const externalEntityDefinition: {
+    readonly name: "ExternalEntity";
+    readonly behavior: "interface";
+    readonly schema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly sourceService: {
+                readonly $ref: "#/definitions/SourceService";
+            };
+            readonly sourceID: {
+                readonly $ref: "#/definitions/SourceID";
+            };
+            readonly sourceURL: {
+                readonly $ref: "#/definitions/SourceURL";
+            };
+            readonly lastSyncedAt: {
+                readonly $ref: "#/definitions/DateTime";
+            };
+        };
+        readonly required: ["sourceService", "sourceID", "lastSyncedAt"];
+        readonly additionalProperties: true;
+        readonly definitions: {
+            readonly SourceService: {
+                readonly type: "string";
+                readonly title: "SourceService";
+                readonly minLength: 1;
+                readonly maxLength: 50;
+            };
+            readonly SourceID: {
+                readonly type: "string";
+                readonly title: "SourceID";
+                readonly minLength: 1;
+                readonly maxLength: 500;
+            };
+            readonly SourceURL: import("json-schema-typed").JSONSchema.String;
+            readonly DateTime: import("json-schema-typed").JSONSchema.String;
+        };
+    };
+    readonly fieldsMeta: {};
+};

package/lib/types.d.ts

@@ -1,5 +1,58 @@
-import type { ClusterModel } from '@kubun/protocol';
+import type { ClustersRecord } from '@kubun/protocol';
 import type { JSONSchema } from 'json-schema-typed';
+export type OAuthProviderDefinition = {
+    name: string;
+    authorizationEndpoint: string;
+    tokenEndpoint: string;
+    baseScopes?: Array<string>;
+    clientID?: string;
+    clientSecret?: string;
+};
+export type Credential = {
+    accessToken: string;
+    refreshToken?: string;
+    expiresAt?: Date;
+    scopes: Array<string>;
+    accountLabel?: string;
+    metadata?: Record<string, unknown>;
+};
+export type CredentialProvider = {
+    get(providerName: string, ownerDID: string): Promise<Credential | null>;
+    set(providerName: string, ownerDID: string, credential: Credential): Promise<void>;
+    delete(providerName: string, ownerDID: string): Promise<void>;
+};
+export type OAuthState = {
+    provider: string;
+    redirectURL: string;
+    connectors?: Array<string>;
+    nonce: string;
+    createdAt: number;
+};
+export type TokenResponse = {
+    access_token: string;
+    refresh_token?: string;
+    expires_in?: number;
+    token_type: string;
+    scope?: string;
+};
+export type SyncStatus = 'idle' | 'syncing' | 'error';
+export type SyncState = {
+    checkpoint: unknown;
+    lastSyncedAt: string;
+    entityCount: number;
+    status: SyncStatus;
+    error?: string;
+};
+export type SyncStateEntry = SyncState & {
+    connectorName: string;
+    ownerDID: string;
+};
+export type SyncStateStore = {
+    get(connectorName: string, ownerDID: string): Promise<SyncState | null>;
+    set(connectorName: string, ownerDID: string, state: SyncState): Promise<void>;
+    delete(connectorName: string, ownerDID: string): Promise<void>;
+    listForConnector(connectorName: string): Promise<Array<SyncStateEntry>>;
+};
 export type SyncBoundary = {
     maxAge?: string;
     since?: string;
@@ -16,6 +69,7 @@ export type EntityRecord = Record<string, unknown> & {
     sourceID: string;
 };
 export type EntityBatch = {
+    modelID: string;
     entities: Array<EntityRecord>;
     deleted?: Array<{
         sourceService: string;
@@ -59,6 +113,7 @@ export type DevicePermission = {
 export type OAuthConnectorAuth = {
     provider: string;
     scopes: Array<string>;
+    writeScopes?: Array<string>;
 };
 export type DeviceConnectorAuth = {
     provider: 'device';
@@ -79,6 +134,13 @@ export type ActionResult = {
     documentID?: string;
     deletedDocumentID?: string;
 };
+export type ActionHandler = {
+    create(model: string, params: Record<string, unknown>): Promise<EntityRecord>;
+    update(model: string, sourceID: string, params: Record<string, unknown>): Promise<EntityRecord>;
+};
+export type ActionHandlerFactory = (config: {
+    credential: Credential;
+}) => ActionHandler;
 export type ServerProviderFactory = (config: {
     credential: unknown;
     boundary: SyncBoundary;
@@ -89,9 +151,10 @@ export type ClientProviderFactory = (config: {
 export type ConnectorDefinition = {
     name: string;
     version: string;
-    cluster: ClusterModel;
+    clusters: ClustersRecord;
     syncStrategies: Array<'polling' | 'webhook' | 'on-demand'>;
     actions?: Array<ActionDefinition>;
+    actionHandler?: ActionHandlerFactory;
     serverProvider?: ServerProviderFactory;
     clientProvider?: ClientProviderFactory;
     graphql?: {
@@ -121,3 +184,13 @@ export type SyncErrorEvent = {
     error: string;
 };
 export type SyncEvent = SyncProgressEvent | SyncCompleteEvent | SyncErrorEvent;
+export type ConnectorSyncEventPayload = {
+    type: 'started' | 'progress' | 'completed' | 'error';
+    connectorName: string;
+    entitiesProcessed?: number;
+    entitiesFailed?: number;
+    totalProcessed?: number;
+    totalFailed?: number;
+    duration?: number;
+    error?: string;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubun/connector",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "license": "see LICENSE.md",
   "keywords": [],
   "type": "module",
@@ -15,25 +15,17 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@enkaku/event": "^0.13.0",
-    "@enkaku/protocol": "^0.13.0",
-    "@enkaku/schema": "^0.13.0",
-    "hono": "^4.11.9",
     "json-schema-typed": "^8.0.2",
-    "@kubun/db": "^0.6.0",
-    "@kubun/scalars": "^0.6.0",
-    "@kubun/models": "^0.6.0",
-    "@kubun/protocol": "^0.6.0",
-    "@kubun/logger": "^0.6.0"
+    "@kubun/protocol": "^0.8.0",
+    "@kubun/scalars": "^0.8.0"
   },
-  "devDependencies": {},
   "scripts": {
     "build:clean": "del lib",
     "build:js": "swc src -d ./lib --config-file ../../swc.json --strip-leading-paths",
     "build:types": "tsc --emitDeclarationOnly --skipLibCheck",
     "build:types:ci": "tsc --emitDeclarationOnly --declarationMap false",
     "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
-    "test:types": "tsc --noEmit",
+    "test:types": "tsc --noEmit -p tsconfig.test.json",
     "test:unit": "vitest run",
     "test": "pnpm run test:types && pnpm run test:unit"
   }

package/lib/manager.d.ts

@@ -1,37 +0,0 @@
-import type { Logger } from '@kubun/logger';
-import type { ConnectorRegistry } from './registry.js';
-import type { SyncBoundary } from './types.js';
-export type ConnectorActivatedEvent = {
-    connectorName: string;
-    graphID: string;
-};
-export type ConnectorDeactivatedEvent = {
-    connectorName: string;
-};
-export type ConnectorManagerEvents = {
-    'connector:activated': ConnectorActivatedEvent;
-    'connector:deactivated': ConnectorDeactivatedEvent;
-};
-export type ConnectorManagerParams = {
-    registry: ConnectorRegistry;
-    logger: Logger;
-    defaults?: {
-        boundary?: SyncBoundary;
-        pollingInterval?: string;
-    };
-};
-export declare class ConnectorManager {
-    #private;
-    constructor(params: ConnectorManagerParams);
-    get defaults(): {
-        boundary: SyncBoundary;
-        pollingInterval: string;
-    };
-    activateForGraph(graphID: string, connectorNames: Array<string>): void;
-    deactivateForGraph(graphID: string, connectorNames: Array<string>): void;
-    isActive(connectorName: string): boolean;
-    getActiveGraphs(connectorName: string): Array<string>;
-    listActive(): Array<string>;
-    onConnectorActivated(callback: (event: ConnectorActivatedEvent) => void): () => void;
-    onConnectorDeactivated(callback: (event: ConnectorDeactivatedEvent) => void): () => void;
-}

package/lib/manager.js

@@ -1 +0,0 @@
-import{EventEmitter as e}from"@enkaku/event";export class ConnectorManager{#e;#t;#r=new Map;#a=new e;#i;constructor(e){this.#e=e.registry,this.#t=e.logger,this.#i={boundary:e.defaults?.boundary??{maxAge:"P90D"},pollingInterval:e.defaults?.pollingInterval??"PT5M"}}get defaults(){return this.#i}activateForGraph(e,t){for(let r of t){if(!this.#e.has(r))throw Error(`Connector "${r}" is not registered`);let t=this.#r.get(r),a=null==t||0===t.size;null==t&&(t=new Set,this.#r.set(r,t)),t.add(e),a&&(this.#t.info("Connector {name} activated by graph {graphID}",{name:r,graphID:e}),this.#a.emit("connector:activated",{connectorName:r,graphID:e}))}}deactivateForGraph(e,t){for(let r of t){let t=this.#r.get(r);null!=t&&(t.delete(e),0===t.size&&(this.#r.delete(r),this.#t.info("Connector {name} deactivated",{name:r}),this.#a.emit("connector:deactivated",{connectorName:r})))}}isActive(e){let t=this.#r.get(e);return null!=t&&t.size>0}getActiveGraphs(e){let t=this.#r.get(e);return t?Array.from(t):[]}listActive(){return Array.from(this.#r.keys()).filter(e=>this.isActive(e))}onConnectorActivated(e){return this.#a.on("connector:activated",e)}onConnectorDeactivated(e){return this.#a.on("connector:deactivated",e)}}

package/lib/oauth/routes.d.ts

@@ -1,19 +0,0 @@
-import { Hono } from 'hono';
-import type { Credential, OAuthProviderDefinition, OAuthState } from './types.js';
-export type StateStore = {
-    set(nonce: string, state: OAuthState): Promise<void> | void;
-    get(nonce: string): Promise<OAuthState | null> | OAuthState | null;
-    delete(nonce: string): Promise<void> | void;
-};
-export type OAuthRoutesParams = {
-    providers: Array<OAuthProviderDefinition>;
-    stateStore: StateStore;
-    /** Maximum age of OAuth state in milliseconds (default: 10 minutes) */
-    stateTTL?: number;
-    onTokenReceived?: (params: {
-        provider: OAuthProviderDefinition;
-        state: OAuthState;
-        credential: Credential;
-    }) => Promise<void> | void;
-};
-export declare function createOAuthRoutes(params: OAuthRoutesParams): Hono;

package/lib/oauth/routes.js

@@ -1 +0,0 @@
-import{Hono as e}from"hono";export function createOAuthRoutes(r){let{providers:t,stateStore:a,stateTTL:i=6e5,onTokenReceived:o}=r,n=new Map(t.map(e=>[e.name,e])),s=new e;return s.get("/auth/:provider/start",async e=>{let r,t=e.req.param("provider"),i=n.get(t);if(!i)return e.json({error:`Unknown provider: ${t}`},404);if(!i.clientID)return e.json({error:`Provider ${t} is not configured with a clientID`},500);let o=e.req.query("redirect_uri");if(!o)return e.json({error:"redirect_uri is required"},400);let s=e.req.query("scope"),c=s?s.split(","):[],d=[...i.baseScopes??[],...c],p=(r=new Uint8Array(32),crypto.getRandomValues(r),Array.from(r,e=>e.toString(16).padStart(2,"0")).join("")),u={provider:t,redirectURL:o,nonce:p,createdAt:Date.now()};await a.set(p,u);let l=new URL(i.authorizationEndpoint);return l.searchParams.set("client_id",i.clientID),l.searchParams.set("redirect_uri",o),l.searchParams.set("response_type","code"),l.searchParams.set("state",p),d.length>0&&l.searchParams.set("scope",d.join(" ")),e.redirect(l.toString())}),s.get("/auth/:provider/callback",async e=>{let r=e.req.param("provider"),t=n.get(r);if(!t)return e.json({error:`Unknown provider: ${r}`},404);let s=e.req.query("code"),c=e.req.query("state"),d=e.req.query("error");if(d){let r=e.req.query("error_description");return e.json({error:d,error_description:r},400)}if(!s||!c)return e.json({error:"Missing code or state"},400);let p=await a.get(c);if(!p)return e.json({error:"Invalid or expired state"},400);if(Date.now()-p.createdAt>i)return await a.delete(c),e.json({error:"State has expired"},400);if(p.provider!==r)return e.json({error:"State provider mismatch"},400);let u=await fetch(t.tokenEndpoint,{method:"POST",headers:{"Content-Type":"application/x-www-form-urlencoded"},body:new URLSearchParams({grant_type:"authorization_code",code:s,redirect_uri:p.redirectURL,client_id:t.clientID??"",client_secret:t.clientSecret??""})});if(!u.ok){let r=await u.text();return e.json({error:"Token exchange failed",details:r},500)}let l=await u.json(),h={accessToken:l.access_token,refreshToken:l.refresh_token,expiresAt:l.expires_in?new Date(Date.now()+1e3*l.expires_in):void 0,scopes:l.scope?l.scope.split(" "):[]};await a.delete(c),o&&await o({provider:t,state:p,credential:h});let w=new URL(p.redirectURL);return w.searchParams.set("oauth_status","success"),w.searchParams.set("provider",r),e.redirect(w.toString())}),s}

package/lib/oauth/types.d.ts

@@ -1,35 +0,0 @@
-export type OAuthProviderDefinition = {
-    name: string;
-    authorizationEndpoint: string;
-    tokenEndpoint: string;
-    baseScopes?: Array<string>;
-    clientID?: string;
-    clientSecret?: string;
-};
-export type Credential = {
-    accessToken: string;
-    refreshToken?: string;
-    expiresAt?: Date;
-    scopes: Array<string>;
-    accountLabel?: string;
-    metadata?: Record<string, unknown>;
-};
-export type CredentialProvider = {
-    get(providerName: string, ownerDID: string): Promise<Credential | null>;
-    set(providerName: string, ownerDID: string, credential: Credential): Promise<void>;
-    delete(providerName: string, ownerDID: string): Promise<void>;
-};
-export type OAuthState = {
-    provider: string;
-    redirectURL: string;
-    connectors?: Array<string>;
-    nonce: string;
-    createdAt: number;
-};
-export type TokenResponse = {
-    access_token: string;
-    refresh_token?: string;
-    expires_in?: number;
-    token_type: string;
-    scope?: string;
-};

package/lib/oauth/types.js

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

package/lib/protocol.d.ts

@@ -1,337 +0,0 @@
-import type { FromSchema } from '@enkaku/schema';
-export declare const connectorProtocol: {
-    readonly 'connector/sync': {
-        readonly type: "stream";
-        readonly param: {
-            readonly type: "object";
-            readonly properties: {
-                readonly connector: {
-                    readonly type: "string";
-                    readonly description: "Connector name";
-                };
-                readonly full: {
-                    readonly type: "boolean";
-                    readonly description: "Force full sync instead of incremental";
-                };
-            };
-            readonly required: readonly ["connector"];
-            readonly additionalProperties: false;
-        };
-        readonly receive: {
-            readonly type: "object";
-            readonly properties: {
-                readonly type: {
-                    readonly type: "string";
-                    readonly enum: readonly ["progress", "entity", "error"];
-                };
-                readonly connectorName: {
-                    readonly type: "string";
-                };
-                readonly phase: {
-                    readonly type: "string";
-                    readonly enum: readonly ["initial", "incremental"];
-                };
-                readonly entitiesProcessed: {
-                    readonly type: "number";
-                };
-                readonly entitiesFailed: {
-                    readonly type: "number";
-                };
-                readonly currentBatch: {
-                    readonly type: "number";
-                };
-                readonly checkpoint: {};
-                readonly entity: {
-                    readonly type: "object";
-                };
-                readonly documentID: {
-                    readonly type: "string";
-                };
-                readonly error: {
-                    readonly type: "string";
-                };
-            };
-            readonly additionalProperties: false;
-        };
-        readonly result: {
-            readonly type: "object";
-            readonly properties: {
-                readonly success: {
-                    readonly type: "boolean";
-                };
-                readonly totalProcessed: {
-                    readonly type: "number";
-                };
-                readonly totalFailed: {
-                    readonly type: "number";
-                };
-                readonly duration: {
-                    readonly type: "number";
-                };
-            };
-            readonly required: readonly ["success", "totalProcessed", "totalFailed", "duration"];
-            readonly additionalProperties: false;
-        };
-    };
-    readonly 'connector/status': {
-        readonly type: "request";
-        readonly param: {
-            readonly type: "object";
-            readonly properties: {
-                readonly connector: {
-                    readonly type: "string";
-                    readonly description: "Optional connector name to filter";
-                };
-            };
-            readonly additionalProperties: false;
-        };
-        readonly result: {
-            readonly type: "object";
-            readonly properties: {
-                readonly connectors: {
-                    readonly type: "array";
-                    readonly items: {
-                        readonly type: "object";
-                        readonly properties: {
-                            readonly name: {
-                                readonly type: "string";
-                            };
-                            readonly lastSyncedAt: {
-                                readonly type: "string";
-                            };
-                            readonly entityCount: {
-                                readonly type: "number";
-                            };
-                            readonly status: {
-                                readonly type: "string";
-                                readonly enum: readonly ["active", "inactive", "syncing", "error"];
-                            };
-                            readonly error: {
-                                readonly type: "string";
-                            };
-                        };
-                        readonly required: readonly ["name", "status"];
-                        readonly additionalProperties: false;
-                    };
-                };
-            };
-            readonly required: readonly ["connectors"];
-            readonly additionalProperties: false;
-        };
-    };
-    readonly 'connector/action': {
-        readonly type: "request";
-        readonly param: {
-            readonly type: "object";
-            readonly properties: {
-                readonly connector: {
-                    readonly type: "string";
-                };
-                readonly action: {
-                    readonly type: "string";
-                };
-                readonly input: {
-                    readonly type: "object";
-                };
-            };
-            readonly required: readonly ["connector", "action", "input"];
-            readonly additionalProperties: false;
-        };
-        readonly result: {
-            readonly type: "object";
-            readonly properties: {
-                readonly raw: {
-                    readonly type: "object";
-                };
-                readonly entity: {
-                    readonly type: "object";
-                };
-                readonly documentID: {
-                    readonly type: "string";
-                };
-                readonly deletedDocumentID: {
-                    readonly type: "string";
-                };
-            };
-            readonly additionalProperties: false;
-        };
-    };
-    readonly 'connector/push': {
-        readonly type: "request";
-        readonly param: {
-            readonly type: "object";
-            readonly properties: {
-                readonly connector: {
-                    readonly type: "string";
-                };
-                readonly batch: {
-                    readonly type: "object";
-                    readonly properties: {
-                        readonly entities: {
-                            readonly type: "array";
-                            readonly items: {
-                                readonly type: "object";
-                            };
-                        };
-                        readonly deleted: {
-                            readonly type: "array";
-                            readonly items: {
-                                readonly type: "object";
-                                readonly properties: {
-                                    readonly sourceService: {
-                                        readonly type: "string";
-                                    };
-                                    readonly sourceID: {
-                                        readonly type: "string";
-                                    };
-                                };
-                                readonly required: readonly ["sourceService", "sourceID"];
-                            };
-                        };
-                        readonly checkpoint: {};
-                        readonly hasMore: {
-                            readonly type: "boolean";
-                        };
-                    };
-                    readonly required: readonly ["entities", "hasMore"];
-                    readonly additionalProperties: false;
-                };
-                readonly checkpoint: {};
-            };
-            readonly required: readonly ["connector", "batch"];
-            readonly additionalProperties: false;
-        };
-        readonly result: {
-            readonly type: "object";
-            readonly properties: {
-                readonly processed: {
-                    readonly type: "number";
-                };
-                readonly failed: {
-                    readonly type: "number";
-                };
-                readonly documentIDs: {
-                    readonly type: "array";
-                    readonly items: {
-                        readonly type: "string";
-                    };
-                };
-            };
-            readonly required: readonly ["processed", "failed", "documentIDs"];
-            readonly additionalProperties: false;
-        };
-    };
-    readonly 'connector/push-complete': {
-        readonly type: "request";
-        readonly param: {
-            readonly type: "object";
-            readonly properties: {
-                readonly connector: {
-                    readonly type: "string";
-                };
-                readonly checkpoint: {};
-            };
-            readonly required: readonly ["connector", "checkpoint"];
-            readonly additionalProperties: false;
-        };
-        readonly result: {
-            readonly type: "object";
-            readonly properties: {
-                readonly acknowledged: {
-                    readonly type: "boolean";
-                };
-            };
-            readonly required: readonly ["acknowledged"];
-            readonly additionalProperties: false;
-        };
-    };
-    readonly 'connector/auth-url': {
-        readonly type: "request";
-        readonly param: {
-            readonly type: "object";
-            readonly properties: {
-                readonly provider: {
-                    readonly type: "string";
-                };
-                readonly redirectURL: {
-                    readonly type: "string";
-                };
-                readonly connectors: {
-                    readonly type: "array";
-                    readonly items: {
-                        readonly type: "string";
-                    };
-                };
-            };
-            readonly required: readonly ["provider", "redirectURL"];
-            readonly additionalProperties: false;
-        };
-        readonly result: {
-            readonly type: "object";
-            readonly properties: {
-                readonly url: {
-                    readonly type: "string";
-                };
-                readonly state: {
-                    readonly type: "string";
-                };
-            };
-            readonly required: readonly ["url", "state"];
-            readonly additionalProperties: false;
-        };
-    };
-    readonly 'connector/auth-complete': {
-        readonly type: "request";
-        readonly param: {
-            readonly type: "object";
-            readonly properties: {
-                readonly provider: {
-                    readonly type: "string";
-                };
-                readonly code: {
-                    readonly type: "string";
-                };
-                readonly state: {
-                    readonly type: "string";
-                };
-            };
-            readonly required: readonly ["provider", "code", "state"];
-            readonly additionalProperties: false;
-        };
-        readonly result: {
-            readonly type: "object";
-            readonly properties: {
-                readonly providerName: {
-                    readonly type: "string";
-                };
-                readonly accountLabel: {
-                    readonly type: "string";
-                };
-                readonly scopes: {
-                    readonly type: "array";
-                    readonly items: {
-                        readonly type: "string";
-                    };
-                };
-            };
-            readonly required: readonly ["providerName", "scopes"];
-            readonly additionalProperties: false;
-        };
-    };
-};
-export type ConnectorProtocol = typeof connectorProtocol;
-export type ConnectorSyncParams = FromSchema<ConnectorProtocol['connector/sync']['param']>;
-export type ConnectorSyncReceive = FromSchema<ConnectorProtocol['connector/sync']['receive']>;
-export type ConnectorSyncResult = FromSchema<ConnectorProtocol['connector/sync']['result']>;
-export type ConnectorStatusParams = FromSchema<ConnectorProtocol['connector/status']['param']>;
-export type ConnectorStatusResult = FromSchema<ConnectorProtocol['connector/status']['result']>;
-export type ConnectorActionParams = FromSchema<ConnectorProtocol['connector/action']['param']>;
-export type ConnectorActionResult = FromSchema<ConnectorProtocol['connector/action']['result']>;
-export type ConnectorPushParams = FromSchema<ConnectorProtocol['connector/push']['param']>;
-export type ConnectorPushResult = FromSchema<ConnectorProtocol['connector/push']['result']>;
-export type ConnectorPushCompleteParams = FromSchema<ConnectorProtocol['connector/push-complete']['param']>;
-export type ConnectorPushCompleteResult = FromSchema<ConnectorProtocol['connector/push-complete']['result']>;
-export type ConnectorAuthURLParams = FromSchema<ConnectorProtocol['connector/auth-url']['param']>;
-export type ConnectorAuthURLResult = FromSchema<ConnectorProtocol['connector/auth-url']['result']>;
-export type ConnectorAuthCompleteParams = FromSchema<ConnectorProtocol['connector/auth-complete']['param']>;
-export type ConnectorAuthCompleteResult = FromSchema<ConnectorProtocol['connector/auth-complete']['result']>;

package/lib/protocol.js

@@ -1 +0,0 @@
-export const connectorProtocol={"connector/sync":{type:"stream",param:{type:"object",properties:{connector:{type:"string",description:"Connector name"},full:{type:"boolean",description:"Force full sync instead of incremental"}},required:["connector"],additionalProperties:!1},receive:{type:"object",properties:{type:{type:"string",enum:["progress","entity","error"]},connectorName:{type:"string"},phase:{type:"string",enum:["initial","incremental"]},entitiesProcessed:{type:"number"},entitiesFailed:{type:"number"},currentBatch:{type:"number"},checkpoint:{},entity:{type:"object"},documentID:{type:"string"},error:{type:"string"}},additionalProperties:!1},result:{type:"object",properties:{success:{type:"boolean"},totalProcessed:{type:"number"},totalFailed:{type:"number"},duration:{type:"number"}},required:["success","totalProcessed","totalFailed","duration"],additionalProperties:!1}},"connector/status":{type:"request",param:{type:"object",properties:{connector:{type:"string",description:"Optional connector name to filter"}},additionalProperties:!1},result:{type:"object",properties:{connectors:{type:"array",items:{type:"object",properties:{name:{type:"string"},lastSyncedAt:{type:"string"},entityCount:{type:"number"},status:{type:"string",enum:["active","inactive","syncing","error"]},error:{type:"string"}},required:["name","status"],additionalProperties:!1}}},required:["connectors"],additionalProperties:!1}},"connector/action":{type:"request",param:{type:"object",properties:{connector:{type:"string"},action:{type:"string"},input:{type:"object"}},required:["connector","action","input"],additionalProperties:!1},result:{type:"object",properties:{raw:{type:"object"},entity:{type:"object"},documentID:{type:"string"},deletedDocumentID:{type:"string"}},additionalProperties:!1}},"connector/push":{type:"request",param:{type:"object",properties:{connector:{type:"string"},batch:{type:"object",properties:{entities:{type:"array",items:{type:"object"}},deleted:{type:"array",items:{type:"object",properties:{sourceService:{type:"string"},sourceID:{type:"string"}},required:["sourceService","sourceID"]}},checkpoint:{},hasMore:{type:"boolean"}},required:["entities","hasMore"],additionalProperties:!1},checkpoint:{}},required:["connector","batch"],additionalProperties:!1},result:{type:"object",properties:{processed:{type:"number"},failed:{type:"number"},documentIDs:{type:"array",items:{type:"string"}}},required:["processed","failed","documentIDs"],additionalProperties:!1}},"connector/push-complete":{type:"request",param:{type:"object",properties:{connector:{type:"string"},checkpoint:{}},required:["connector","checkpoint"],additionalProperties:!1},result:{type:"object",properties:{acknowledged:{type:"boolean"}},required:["acknowledged"],additionalProperties:!1}},"connector/auth-url":{type:"request",param:{type:"object",properties:{provider:{type:"string"},redirectURL:{type:"string"},connectors:{type:"array",items:{type:"string"}}},required:["provider","redirectURL"],additionalProperties:!1},result:{type:"object",properties:{url:{type:"string"},state:{type:"string"}},required:["url","state"],additionalProperties:!1}},"connector/auth-complete":{type:"request",param:{type:"object",properties:{provider:{type:"string"},code:{type:"string"},state:{type:"string"}},required:["provider","code","state"],additionalProperties:!1},result:{type:"object",properties:{providerName:{type:"string"},accountLabel:{type:"string"},scopes:{type:"array",items:{type:"string"}}},required:["providerName","scopes"],additionalProperties:!1}}};

package/lib/registry.d.ts

@@ -1,10 +0,0 @@
-import type { ConnectorDefinition } from './types.js';
-export declare class ConnectorRegistry {
-    #private;
-    register(connector: ConnectorDefinition): void;
-    unregister(name: string): void;
-    get(name: string): ConnectorDefinition | undefined;
-    has(name: string): boolean;
-    list(): Array<string>;
-    getAll(): Array<ConnectorDefinition>;
-}

package/lib/registry.js

@@ -1 +0,0 @@
-export class ConnectorRegistry{#e=new Map;register(e){if(this.#e.has(e.name))throw Error(`Connector "${e.name}" is already registered`);this.#e.set(e.name,e)}unregister(e){this.#e.delete(e)}get(e){return this.#e.get(e)}has(e){return this.#e.has(e)}list(){return Array.from(this.#e.keys())}getAll(){return Array.from(this.#e.values())}}

package/lib/sync/boundary.d.ts

@@ -1,4 +0,0 @@
-import type { SyncBoundary } from '../types.js';
-export declare function parseDuration(duration: string): number | undefined;
-export declare function computeEffectiveBoundary(serverBoundary: SyncBoundary, userBoundary: SyncBoundary | undefined): SyncBoundary;
-export declare function isWithinBoundary(date: Date, boundary: SyncBoundary): boolean;

package/lib/sync/boundary.js

@@ -1 +0,0 @@
-let e=/^P(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?$/;export function parseDuration(n){let i=e.exec(n);if(!i)return;let t=Number.parseInt(i[1]??"0",10),l=Number.parseInt(i[2]??"0",10),a=Number.parseInt(i[3]??"0",10),u=Number.parseInt(i[4]??"0",10);if(0!==t||0!==l||0!==a||0!==u)return((24*t+l)*60+a)*6e4+1e3*u}export function computeEffectiveBoundary(e,n){if(null==n)return e;let i={};if(null!=e.maxAge||null!=n.maxAge){let t=e.maxAge?parseDuration(e.maxAge):void 0,l=n.maxAge?parseDuration(n.maxAge):void 0;null!=t&&null!=l?i.maxAge=t<=l?e.maxAge:n.maxAge:i.maxAge=e.maxAge??n.maxAge}if(null!=e.since||null!=n.since){let t=e.since?new Date(e.since):void 0,l=n.since?new Date(n.since):void 0;null!=t&&null!=l?i.since=t>=l?e.since:n.since:i.since=e.since??n.since}if(null!=e.maxEntities||null!=n.maxEntities){let t=e.maxEntities,l=n.maxEntities;null!=t&&null!=l?i.maxEntities=Math.min(t,l):i.maxEntities=e.maxEntities??n.maxEntities}return i}export function isWithinBoundary(e,n){let i=Date.now();if(null!=n.maxAge){let t=parseDuration(n.maxAge);if(null!=t&&e.getTime()<i-t)return!1}if(null!=n.since){let i=new Date(n.since);if(e.getTime()<i.getTime())return!1}return!0}