@vibesdotdev/integrations-microsoft 0.0.0-stage → 1.0.0-rc.1

package/dist/sharepoint/sharepoint.adapter.impl.js

@@ -0,0 +1,645 @@
+/**
+ * SharePoint Storage Adapter Implementation
+ *
+ * Wraps the GraphSharePointClient in the StorageAdapterInterface.
+ * Provides document protocol operations: list, get, put, delete
+ * against SharePoint drives via Microsoft Graph API.
+ *
+ * Usage:
+ * ```ts
+ * const adapter = await runtime.query('storage/adapter')
+ *   .withId('sharepoint').resolve();
+ * const store = adapter.documentStore(containerId, schema);
+ * ```
+ */
+import { CapabilityError, CaughtFailureSchema, settle, valueFreeFailure, createRuntimeImplementation } from '@vibesdotdev/kernel';
+import { admitMicrosoft, MicrosoftGraphError, microsoftFailure } from "../schemas/boundary.js";
+import { IntegrationProviderResolvedConfigurationSchema } from '@vibesdotdev/integrations/schemas/integration-descriptor';
+import { createMicrosoftSecretsFetch, microsoftAppCredentialBinding, microsoftDelegatedCredentialBinding } from "../microsoft/secrets-fetch.js";
+import { MicrosoftConfigSchema } from "../schemas/boundary.js";
+import { SharePointAdapterOverrideSchema, SharePointFolderManifestSchema } from "../schemas/sharepoint.js";
+import { SharePointAdapterConfigSchema } from "./sharepoint.schemas.js";
+import { getLogger } from '@vibesdotdev/logging';
+import { z } from 'zod/v4';
+import { GraphSharePointClient, ONEDRIVE_SITE_ID } from "../microsoft/graph-sharepoint-client.js";
+import { browseDriveWithPathFallback, searchDriveWithPathFallback } from "../microsoft/graph-drive-fallback.js";
+import { SharePointDocumentRecordSchema, SharePointUploadMetadataSchema } from "./sharepoint.schemas.js";
+function describeError(error) {
+    const failure = microsoftFailure(error);
+    return `${failure.code}: ${failure.reason}`;
+}
+function logWarn(runtime, message, meta) {
+    if (!runtime)
+        throw new CapabilityError('Partial Microsoft results require a runtime observer.', 'UNAVAILABLE', { reason: 'integration-runtime-required' });
+    getLogger('integrations-microsoft', runtime).child('sharepoint').warn(message, meta);
+}
+// SharePoint Document Store
+/**
+ * Document store backed by a SharePoint drive folder.
+ *
+ * The "containerId" is the SharePoint site ID.
+ * The store provides list/get/put/delete operations
+ * mapped to Graph API drive item endpoints.
+ */
+class SharePointDocumentStore {
+    schema;
+    client;
+    siteId;
+    folderPath;
+    runtime;
+    constructor(client, siteId, folderPath, runtime, schema) {
+        this.schema = schema;
+        this.client = client;
+        this.siteId = siteId;
+        this.folderPath = folderPath;
+        this.runtime = runtime;
+    }
+    async load() {
+        const items = await this.client.browseDrive(this.siteId, this.folderPath);
+        return admitMicrosoft(this.schema, items
+            .filter((item) => !item.isFolder)
+            .map((item) => ({
+            id: item.id,
+            name: item.name,
+            size: item.size,
+            modifiedAt: item.lastModified,
+            mimeType: item.mimeType,
+            webUrl: item.webUrl,
+            containerId: this.siteId
+        })));
+    }
+    async save(_data) {
+        throw new Error('SharePoint document store does not support bulk save. Use put() for individual uploads.');
+    }
+    async exists() {
+        const attempt = await settle(() => this.client.browseDrive(this.siteId, this.folderPath));
+        if (attempt.ok)
+            return true;
+        if (attempt.cause instanceof MicrosoftGraphError && attempt.cause.status === 404)
+            return false;
+        throw attempt.cause;
+    }
+    async delete() {
+        throw new Error('SharePoint document store does not support bulk delete. Use deleteItem() on the adapter.');
+    }
+    getPath() {
+        const folder = this.folderPath ? `/${this.folderPath}` : '';
+        return `sharepoint://${this.siteId}${folder}`;
+    }
+}
+// SharePoint Object Store (object protocol — binary blobs)
+/**
+ * Key-addressed object store backed by a SharePoint site drive, scoped to a
+ * base folder. Keys are drive-relative paths under `basePath`. URLs prefer
+ * temporary signed Graph URLs and fall back to proxy streaming via `get()`.
+ */
+class SharePointObjectStore {
+    resolveClient;
+    siteId;
+    basePath;
+    runtime;
+    constructor(resolveClient, siteId, basePath, runtime) {
+        this.resolveClient = resolveClient;
+        this.siteId = siteId;
+        this.basePath = basePath;
+        this.runtime = runtime;
+    }
+    /** Map an opaque object key to a drive-relative path under `basePath`. */
+    fullPath(key) {
+        const base = this.basePath.replace(/^\/+|\/+$/g, '');
+        const k = key.replace(/^\/+/, '');
+        return base ? `${base}/${k}` : k;
+    }
+    async put(key, body, opts) {
+        const client = await this.resolveClient();
+        const item = await client.uploadFile(this.siteId, this.fullPath(key), body, {
+            contentType: opts?.contentType,
+            conflictBehavior: 'replace'
+        });
+        return { key, size: item.size, contentType: item.mimeType || opts?.contentType };
+    }
+    async get(key) {
+        const client = await this.resolveClient();
+        return client.getStream(this.siteId, this.fullPath(key));
+    }
+    async head(key) {
+        const client = await this.resolveClient();
+        const meta = await client.headPath(this.siteId, this.fullPath(key));
+        if (!meta)
+            return null;
+        return {
+            key,
+            size: meta.size,
+            contentType: meta.mimeType || undefined,
+            lastModified: meta.lastModified || undefined
+        };
+    }
+    async delete(key) {
+        const client = await this.resolveClient();
+        await client.deletePath(this.siteId, this.fullPath(key));
+    }
+    async list(prefix = '', _opts) {
+        const client = await this.resolveClient();
+        const prefixRel = prefix.replace(/^\/+|\/+$/g, '');
+        const folder = this.fullPath(prefixRel);
+        const entries = await client.browseDrive(this.siteId, folder || undefined);
+        const objects = entries
+            .filter((entry) => !entry.isFolder)
+            .map((entry) => ({
+            key: prefixRel ? `${prefixRel}/${entry.name}` : entry.name,
+            size: entry.size,
+            lastModified: entry.lastModified || undefined
+        }));
+        // Shallow listing (immediate children), matching browseDrive.
+        return { objects, hasMore: false };
+    }
+    async url(key, _opts) {
+        // Prefer Graph's pre-authenticated download URL — a short-lived Azure Blob
+        // SAS that needs no auth header — so the browser can <img>/<iframe>/download
+        // it directly, cross-origin. This is what makes SharePoint/OneDrive file
+        // preview + download work from the explorer (incl. the cross-app casework
+        // host, where a same-origin proxy couldn't carry the platform session).
+        // Fall back to proxy serving (get()) only when Graph returns no URL.
+        const client = await this.resolveClient();
+        const signed = await client.getDownloadUrlByPath(this.siteId, this.fullPath(key));
+        if (signed)
+            return { kind: 'signed', url: signed };
+        return { kind: 'proxy', url: this.fullPath(key) };
+    }
+}
+// SharePoint Storage Adapter
+/**
+ * Storage adapter wrapping Microsoft Graph SharePoint client.
+ *
+ * Supports the document protocol for browsing, uploading,
+ * downloading, and deleting documents in SharePoint drives.
+ *
+ * The adapter requires a GraphSharePointClient instance
+ * which supplies its runtime-owned authenticated transport.
+ */
+export class SharePointStorageAdapter {
+    id;
+    capabilities;
+    config = {};
+    client = null;
+    constructor(descriptor) {
+        this.id = descriptor.id;
+        this.capabilities = {
+            protocols: descriptor.protocols ?? ['document'],
+            capabilities: descriptor.capabilities ?? ['list', 'read', 'write', 'browse', 'search'],
+            requiresPairSchema: descriptor.requiresPairSchema ?? false,
+            supportsTransactions: descriptor.supportsTransactions ?? false,
+            supportsTTL: false,
+            supportsFTS: false,
+            persistent: descriptor.persistent ?? true,
+            supportsSubscription: false,
+            supportsHierarchy: descriptor.supportsHierarchy ?? true,
+            supportsComputedFields: false,
+            supportsSideEffects: false,
+            supportsRawQueries: false
+        };
+    }
+    configure(config) {
+        this.config = { ...admitMicrosoft(SharePointAdapterConfigSchema, config), runtime: config.runtime };
+    }
+    /**
+     * Set the GraphSharePointClient instance.
+     * Must be called before using the adapter.
+     */
+    setClient(client) {
+        this.client = client;
+    }
+    isConfigured() {
+        return this.client !== null;
+    }
+    /**
+     * Ensure the GraphSharePointClient is available.
+     */
+    ensureClient() {
+        if (!this.client) {
+            throw new Error('SharePoint storage adapter is not configured. Call setClient() with a GraphSharePointClient instance.');
+        }
+        return this.client;
+    }
+    /**
+     * Resolve the GraphSharePointClient for a browse call.
+     *
+     * Prefers an explicitly-injected client (`setClient()`). Otherwise lazily
+     * resolves the delegated Microsoft integration provider from the runtime and
+     * builds a request-scoped reference-only client from it. Inside a request context
+     * (e.g. the platform-web `/api/storage/adapters/sharepoint/*` route wraps the
+     * call in `runWithRequestContext`) it binds to the calling user's delegated
+     * Graph token. This mirrors the integration-ops dispatch path so browse works
+     * without the singleton needing a pre-set client.
+     */
+    async resolveBrowseClient(integrationId, runtime = this.config.runtime) {
+        if (this.client)
+            return this.client;
+        // Default to the app-only org integration (platform owns the org's
+        // SharePoint via its app creds). Per-user delegated access is opt-in via
+        // `integrationId = 'integration.microsoft.delegated'`. The BROWSE path sets
+        // it on `this.config` via configure(); the OBJECT path can't mutate the
+        // shared `this.config` (it would race across concurrent scopes), so it
+        // threads the id explicitly here — without it, uploads/reads to a delegated
+        // drive would fall back to app-only and Graph rejects `/me` ("only valid
+        // with delegated authentication flow").
+        const resolvedId = integrationId ??
+            this.config.integrationId ??
+            'integration.microsoft';
+        if (!runtime) {
+            throw new CapabilityError('SharePoint storage adapter needs the runtime it is configured on to resolve a Microsoft credential.', 'UNAVAILABLE', { reason: 'runtime-unavailable', retryable: false });
+        }
+        const acquirer = await runtime
+            .query('integration/provider')
+            .withId(resolvedId)
+            .resolve()
+            .catch((error) => {
+            // Only confirmed absence of this provider means "no credential"; any other failure propagates.
+            if (error instanceof Error && CapabilityError.isAbsenceOf(error, 'integration/provider', resolvedId))
+                return null;
+            throw error;
+        });
+        if (!acquirer)
+            throw new CapabilityError('Microsoft provider was not found.', 'NOT_FOUND', { reason: 'microsoft-provider-not-found' });
+        if (!acquirer.getCredentialUseConfiguration) {
+            throw new CapabilityError('Microsoft provider reference delivery is unavailable.', 'UNAVAILABLE', { reason: 'microsoft-credential-references-required' });
+        }
+        const readConfiguration = acquirer.getCredentialUseConfiguration.bind(acquirer);
+        // Re-read live references for every request; this client never caches a
+        // calling user's connection or a tenant's credential.
+        const authenticatedFetch = async (input, init) => {
+            const resolved = admitMicrosoft(IntegrationProviderResolvedConfigurationSchema, await readConfiguration());
+            const credentials = resolved.credentialReferences;
+            const delegated = credentials.accessToken;
+            let binding;
+            if (delegated?.length)
+                binding = microsoftDelegatedCredentialBinding(delegated);
+            else {
+                const clientId = credentials.clientId ?? [];
+                const clientSecret = credentials.clientSecret ?? [];
+                const tenantId = credentials.tenantId ?? [];
+                const config = admitMicrosoft(MicrosoftConfigSchema, resolved.config);
+                binding = microsoftAppCredentialBinding({ clientId, clientSecret, tenantId, tenant: config.tenantId || undefined, scopes: config.scopes ?? ['https://graph.microsoft.com/.default'] });
+            }
+            return createMicrosoftSecretsFetch(runtime, binding)(input, init);
+        };
+        return new GraphSharePointClient({ authenticatedFetch, fetchFn: createMicrosoftSecretsFetch(runtime) });
+    }
+    // Document Store
+    /**
+     * Get a document store for a SharePoint container.
+     *
+     * @param namespace - The SharePoint site ID (container ID)
+     * @param schema - Zod schema (validated on load)
+     * @param manifest - Optional folder path string for subfolder browsing
+     */
+    documentStore(namespace, schema, manifest) {
+        const client = this.ensureClient();
+        const folderPath = admitMicrosoft(SharePointFolderManifestSchema, manifest);
+        const siteId = this.config.siteId ?? namespace;
+        return new SharePointDocumentStore(client, siteId, folderPath, this.config.runtime, schema);
+    }
+    // Object Store (object protocol — binary blobs)
+    /**
+     * Get a key-addressed object store scoped to a SharePoint site + base folder.
+     * Keys are drive-relative paths under `basePath`. The Graph client is resolved
+     * lazily per call — the injected client (`setClient`) when present, else the
+     * configured Microsoft integration in the current request context (app-only
+     * or delegated, per `config.integrationId`).
+     *
+     * @param namespace Optional site id (falls back to `config.siteId`).
+     * @param config Optional `{ siteId?, basePath? }` overrides.
+     */
+    objectStore(namespace, config) {
+        const overrides = admitMicrosoft(SharePointAdapterOverrideSchema, config ?? {});
+        const siteId = overrides.siteId ?? this.config.siteId ?? namespace ?? '';
+        const basePath = overrides.basePath ??
+            this.config.basePath ??
+            '';
+        // Object ops receive their config PER CALL (the resolved adapter is shared,
+        // so configure() would race across scopes) — thread the integration id into
+        // the lazily-built client so a delegated drive uses the user's token, not
+        // app-only (Graph rejects `/me` under app-only auth).
+        const integrationId = overrides.integrationId ??
+            this.config.integrationId;
+        const runtime = (config?.runtime ?? this.config.runtime);
+        return new SharePointObjectStore(() => this.resolveBrowseClient(integrationId, config?.runtime ?? this.config.runtime), siteId, basePath, runtime);
+    }
+    // Browse (canonical `storage/adapter` browse interface)
+    /**
+     * Enumerate the SharePoint sites this credential can reach.
+     *
+     * Each site is surfaced as a {@link StorageDrive} with `kind: 'site'`.
+     * Consumers use the returned `id` as `driveId` for {@link list}.
+     */
+    async listDrives() {
+        const client = await this.resolveBrowseClient();
+        const integrationId = this.config.integrationId ?? 'integration.microsoft';
+        const isDelegated = integrationId === 'integration.microsoft.delegated';
+        const drives = [];
+        // Delegated (per-user) → the signed-in user's personal OneDrive. App-only
+        // tokens have no `/me`, so OneDrive is delegated-only.
+        if (isDelegated) {
+            drives.push({ id: ONEDRIVE_SITE_ID, name: 'OneDrive', kind: 'drive' });
+        }
+        // SharePoint sites the credential can reach. Surface each site's default
+        // document library as the storage drive id; callers can pass that stable
+        // Graph drive id back to browse/search without treating site ids as drives.
+        // Sites that enumerate but whose default drive is missing/inaccessible are
+        // skipped unless every app-only site fails, which indicates a real config
+        // problem rather than stale delegated visibility.
+        const sites = await settle(() => client.listSites());
+        if (!sites.ok) {
+            if (!isDelegated)
+                throw sites.cause;
+            logWarn(this.config.runtime, 'SharePoint enumeration failed; OneDrive remains available', { failure: valueFreeFailure(sites.cause) });
+            return drives;
+        }
+        const failures = [];
+        for (const site of sites.value) {
+            const result = await settle(() => client.getDefaultDrive(site.id));
+            if (!result.ok) {
+                failures.push(result.cause);
+                logWarn(this.config.runtime, 'SharePoint default drive unavailable', { failure: valueFreeFailure(result.cause) });
+                continue;
+            }
+            const drive = result.value;
+            const name = drive.name && drive.name !== site.name ? `${site.name} / ${drive.name}` : site.name;
+            drives.push({ id: drive.id, name, kind: 'site' });
+        }
+        if (!isDelegated && sites.value.length > 0 && failures.length === sites.value.length) {
+            throw new CapabilityError('All SharePoint default drives failed.', 'UNAVAILABLE', {
+                reason: 'microsoft-drives-unavailable', cause: new AggregateError(failures), details: { failedCount: failures.length }
+            });
+        }
+        return drives;
+    }
+    /**
+     * Enumerate files and folders inside a SharePoint site's default drive.
+     *
+     * @param driveId - SharePoint site id (from {@link listDrives}).
+     * @param path - Path relative to the drive root. Defaults to the root
+     *   when omitted or empty.
+     * @returns Mixed `file` and `directory` entries at that path.
+     */
+    async list(driveId, path) {
+        const client = await this.resolveBrowseClient();
+        const siteId = this.config.siteId ?? driveId;
+        const folderPath = path && path.length > 0 ? path : undefined;
+        const items = await browseDriveWithPathFallback(client, siteId, folderPath);
+        const prefix = folderPath ? `${folderPath.replace(/\/+$/, '')}/` : '';
+        return items.map((item) => ({
+            id: item.id,
+            name: item.name,
+            path: `${prefix}${item.name}`,
+            kind: item.isFolder ? 'directory' : 'file',
+            sizeBytes: item.isFolder ? undefined : item.size,
+            modifiedAt: item.lastModified || undefined
+        }));
+    }
+    /**
+     * Search for files matching a text query within a SharePoint drive.
+     *
+     * Delegates to Graph's server-side recursive drive search so results can
+     * be deeply nested (not limited to one folder level like {@link list}).
+     * Only files are returned — Graph search hits are always file-type items.
+     *
+     * @param driveId - SharePoint site id (from {@link listDrives}).
+     * @param query - Free-text search query (file name + content for indexed types).
+     * @param opts.path - Optional drive-root-relative subtree to scope the search.
+     * @param opts.limit - Maximum number of results (default 50, max 200).
+     * @returns Matching entries as {@link StorageEntry}s.
+     */
+    async search(driveId, query, opts) {
+        const client = await this.resolveBrowseClient();
+        const siteId = this.config.siteId ?? driveId;
+        const hits = await searchDriveWithPathFallback(client, siteId, query, {
+            scopePath: opts?.path,
+            limit: opts?.limit
+        });
+        return hits.map((hit) => {
+            const prefix = hit.parentPath ? `${hit.parentPath}/` : '';
+            return {
+                id: hit.id,
+                name: hit.name,
+                path: `${prefix}${hit.name}`,
+                kind: hit.isFolder ? 'directory' : 'file',
+                sizeBytes: hit.isFolder ? undefined : hit.size,
+                modifiedAt: hit.lastModified || undefined
+            };
+        });
+    }
+    /**
+     * Mint a fresh pre-authenticated download URL for a file entry (canonical
+     * `storage/adapter` source-mint extension). By ITEM ID first — Graph search
+     * hits can carry partial parent paths (observed: bare filenames for nested
+     * files), and ids survive moves/renames — falling back to path addressing.
+     * Config is per-call for the same reason as {@link objectStore}: the
+     * resolved adapter is shared, so `configure()` would race across scopes.
+     */
+    async sourceUrlForEntry(driveId, ref, config) {
+        const overrides = admitMicrosoft(SharePointAdapterOverrideSchema, config ?? {});
+        const integrationId = overrides.integrationId ??
+            this.config.integrationId;
+        const client = await this.resolveBrowseClient(integrationId, config?.runtime ?? this.config.runtime);
+        const siteId = overrides.siteId ?? this.config.siteId ?? driveId;
+        const runtime = (config?.runtime ?? this.config.runtime);
+        if (ref.itemId) {
+            const attempt = await settle(() => client.getDownloadUrl(siteId, ref.itemId));
+            if (attempt.ok)
+                return attempt.value.url;
+            if (!(attempt.cause instanceof MicrosoftGraphError) || attempt.cause.status !== 404)
+                throw attempt.cause;
+            logWarn(runtime, 'SharePoint item id is absent; trying path addressing', { failure: valueFreeFailure(attempt.cause) });
+        }
+        if (ref.path) {
+            return client.getDownloadUrlByPath(siteId, ref.path);
+        }
+        return null;
+    }
+    async listItem(driveId, itemId) {
+        const client = await this.resolveBrowseClient();
+        const siteId = this.config.siteId ?? driveId;
+        const items = await client.browseDriveItem(siteId, itemId);
+        return items.map((item) => ({
+            id: item.id,
+            name: item.name,
+            path: item.name,
+            kind: item.isFolder ? 'directory' : 'file',
+            sizeBytes: item.isFolder ? undefined : item.size,
+            modifiedAt: item.lastModified || undefined
+        }));
+    }
+    // SharePoint-specific Document Operations
+    /**
+     * List documents (files only) in a SharePoint site, returning the
+     * SharePoint-typed record shape. Distinct from the canonical
+     * {@link list} browse method which returns {@link StorageEntry}s of
+     * both files and folders.
+     *
+     * @param containerId - SharePoint site ID
+     */
+    async listDocuments(containerId) {
+        const client = this.ensureClient();
+        const siteId = this.config.siteId ?? containerId;
+        const items = await client.browseDrive(siteId);
+        return items
+            .filter((item) => !item.isFolder)
+            .map((item) => ({
+            id: item.id,
+            name: item.name,
+            size: item.size,
+            modifiedAt: item.lastModified,
+            mimeType: item.mimeType,
+            webUrl: item.webUrl,
+            containerId: siteId
+        }));
+    }
+    /**
+     * Get a document with its content stream.
+     *
+     * @param documentId - Drive item ID
+     * @param siteId - Optional site ID (falls back to configured siteId)
+     * @returns Object with metadata and content Blob
+     */
+    async get(documentId, siteId) {
+        const client = this.ensureClient();
+        const sid = this.config.siteId ?? siteId ?? '';
+        const [blob, items] = await Promise.all([
+            client.downloadFile(sid, documentId),
+            client.browseDrive(sid)
+        ]);
+        const item = items.find((i) => i.id === documentId);
+        if (!item) {
+            throw new Error(`Document ${documentId} not found in SharePoint`);
+        }
+        const metadata = {
+            id: item.id,
+            name: item.name,
+            size: item.size,
+            modifiedAt: item.lastModified,
+            mimeType: item.mimeType,
+            webUrl: item.webUrl,
+            containerId: sid
+        };
+        return { metadata, content: blob };
+    }
+    /**
+     * Upload a document to SharePoint.
+     *
+     * Uses the Graph API upload endpoint:
+     * PUT /sites/{site-id}/drive/root:/{folderPath}/{filename}:/content
+     *
+     * @param containerId - SharePoint site ID
+     * @param metadata - Upload metadata (name, contentType, conflictBehavior)
+     * @param content - File content as ArrayBuffer or Blob
+     * @returns Created document record
+     */
+    async put(containerId, metadata, content) {
+        const client = this.ensureClient();
+        const parsed = SharePointUploadMetadataSchema.parse(metadata);
+        const sid = this.config.siteId ?? containerId;
+        const item = await client.uploadFile(sid, parsed.name, content, {
+            contentType: parsed.contentType,
+            conflictBehavior: 'replace'
+        });
+        return SharePointDocumentRecordSchema.parse({
+            id: item.id,
+            name: item.name,
+            size: item.size,
+            modifiedAt: item.lastModified || new Date().toISOString(),
+            mimeType: item.mimeType,
+            webUrl: item.webUrl,
+            containerId: sid
+        });
+    }
+    /**
+     * Delete a document from SharePoint.
+     *
+     * DELETE /sites/{site-id}/drive/items/{item-id}
+     *
+     * @param documentId - Drive item ID to delete
+     * @param siteId - Optional site ID (falls back to configured siteId)
+     */
+    async delete(documentId, siteId) {
+        const client = this.ensureClient();
+        const sid = this.config.siteId ?? siteId ?? '';
+        await client.deleteItem(sid, documentId);
+    }
+    // Not Supported (adapter only implements document protocol)
+    keyValueStore(_namespace, _keySchema, _valueSchema) {
+        throw new Error('SharePoint adapter does not support key-value protocol');
+    }
+    repository(_tableName, _schema, _options) {
+        throw new Error('SharePoint adapter does not support repository protocol');
+    }
+    record(_descriptor) {
+        throw new Error('SharePoint adapter does not support record protocol');
+    }
+    // Database Access
+    async ensureReady() {
+        if (!this.client) {
+            throw new Error('SharePoint storage adapter not configured. Call setClient() with a GraphSharePointClient.');
+        }
+    }
+    getDatabaseConnection() {
+        throw new Error('SharePoint adapter does not provide a database connection. Use the browse (list/listDrives) or document (listDocuments/get/put/delete) APIs.');
+    }
+    // Lifecycle
+    async initialize() {
+        if (!this.client) {
+            throw new Error('SharePoint storage adapter not configured. Call setClient() with a GraphSharePointClient.');
+        }
+    }
+    async close() {
+        // No persistent connections to close
+    }
+    async healthCheck() {
+        if (!this.client) {
+            return {
+                healthy: false,
+                error: 'No GraphSharePointClient configured'
+            };
+        }
+        const start = Date.now();
+        const result = await settle(() => this.client.listSites());
+        if (result.ok)
+            return { healthy: true, latencyMs: Date.now() - start };
+        return { healthy: false, error: describeError(result.cause) };
+    }
+}
+// Implementation Export (runtime registration)
+const defaultDescriptor = {
+    id: 'sharepoint',
+    kind: 'storage/adapter',
+    name: 'SharePoint Storage',
+    description: 'Document + object storage backed by Microsoft SharePoint via Graph API.',
+    protocols: ['document', 'object'],
+    capabilities: ['list', 'read', 'write', 'browse', 'search'],
+    requiresPairSchema: false,
+    supportsTransactions: false,
+    supportsTTL: false,
+    supportsSearch: true,
+    supportsFTS: false,
+    persistent: true,
+    supportsSubscription: false,
+    supportsHierarchy: true,
+    supportsComputedFields: false,
+    supportsSideEffects: false,
+    supportsRawQueries: false,
+    enabled: true
+};
+/**
+ * Builds one adapter instance for one runtime. The adapter holds per-configure
+ * state (`config.runtime`, injected client), so the plugin's loader calls this
+ * once per runtime; a module-level instance would cross-talk between runtimes.
+ */
+export function createSharePointAdapterImplementation() {
+    return createRuntimeImplementation({
+        id: 'sharepoint',
+        kind: 'storage/adapter',
+        implementation: new SharePointStorageAdapter(defaultDescriptor)
+    });
+}
+export default createSharePointAdapterImplementation;
+//# sourceMappingURL=sharepoint.adapter.impl.js.map