@libai168/dsh-tool-google-drive 0.2.0

package/lib/client.js

@@ -0,0 +1,467 @@
+/** Google Drive API client with injected fetch for testability. */
+export class GoogleDriveError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'GoogleDriveError';
+    }
+}
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function asString(record, key) {
+    const value = record[key];
+    return typeof value === 'string' ? value : value != null ? String(value) : '';
+}
+function asNumber(record, key) {
+    const value = record[key];
+    return typeof value === 'number' ? value : Number(value ?? 0) || 0;
+}
+function asBoolean(record, key) {
+    const value = record[key];
+    return typeof value === 'boolean' ? value : false;
+}
+function toJson(value) {
+    try {
+        return JSON.stringify(value ?? {});
+    }
+    catch {
+        return '{}';
+    }
+}
+function mapOwners(value) {
+    return asArray(value).map(item => {
+        const record = asRecord(item);
+        return {
+            displayName: asString(record, 'displayName') || asString(record, 'display_name'),
+            emailAddress: asString(record, 'emailAddress') || asString(record, 'email_address'),
+        };
+    });
+}
+function mapFile(data) {
+    const r = asRecord(data);
+    return {
+        id: asString(r, 'id'),
+        name: asString(r, 'name'),
+        mimeType: asString(r, 'mimeType'),
+        kind: asString(r, 'kind'),
+        description: asString(r, 'description'),
+        iconLink: asString(r, 'iconLink'),
+        webViewLink: asString(r, 'webViewLink'),
+        webContentLink: asString(r, 'webContentLink'),
+        size: asString(r, 'size'),
+        starred: asBoolean(r, 'starred'),
+        trashed: asBoolean(r, 'trashed'),
+        modifiedTime: asString(r, 'modifiedTime'),
+        createdTime: asString(r, 'createdTime'),
+        driveId: asString(r, 'driveId'),
+        parents: asArray(r.parents).map(v => String(v)),
+        owners: mapOwners(r.owners),
+    };
+}
+function mapPermission(data) {
+    const r = asRecord(data);
+    return {
+        id: asString(r, 'id'),
+        type: asString(r, 'type'),
+        kind: asString(r, 'kind'),
+        role: asString(r, 'role'),
+        emailAddress: asString(r, 'emailAddress'),
+        displayName: asString(r, 'displayName'),
+        allowFileDiscovery: asBoolean(r, 'allowFileDiscovery'),
+        expirationTime: asString(r, 'expirationTime'),
+        deleted: asBoolean(r, 'deleted'),
+        permissionDetails: toJson(r.permissionDetails),
+    };
+}
+function mapRevision(data) {
+    const r = asRecord(data);
+    return {
+        id: asString(r, 'id'),
+        mimeType: asString(r, 'mimeType'),
+        modifiedTime: asString(r, 'modifiedTime'),
+        keepForever: asBoolean(r, 'keepForever'),
+        published: asBoolean(r, 'published'),
+        publishAuto: asBoolean(r, 'publishAuto'),
+        publishedOutsideDomain: asBoolean(r, 'publishedOutsideDomain'),
+        size: asString(r, 'size'),
+        originalFilename: asString(r, 'originalFilename'),
+        md5Checksum: asString(r, 'md5Checksum'),
+        downloadUrl: asString(r, 'downloadUrl'),
+        exportLinks: toJson(r.exportLinks),
+    };
+}
+function mapSharedDrive(data) {
+    const r = asRecord(data);
+    return {
+        id: asString(r, 'id'),
+        name: asString(r, 'name'),
+        colorRgb: asString(r, 'colorRgb'),
+        backgroundImageLink: asString(r, 'backgroundImageLink'),
+        createdTime: asString(r, 'createdTime'),
+        hidden: asBoolean(r, 'hidden'),
+        themeId: asString(r, 'themeId'),
+        capabilities: toJson(r.capabilities),
+        restrictions: toJson(r.restrictions),
+    };
+}
+function mapSheetProperties(data) {
+    const r = asRecord(data);
+    return {
+        sheetId: asNumber(r, 'sheetId'),
+        title: asString(r, 'title'),
+        index: asNumber(r, 'index'),
+        sheetType: asString(r, 'sheetType'),
+        rowCount: asNumber(asRecord(r.gridProperties), 'rowCount'),
+        columnCount: asNumber(asRecord(r.gridProperties), 'columnCount'),
+        frozenRowCount: asNumber(asRecord(r.gridProperties), 'frozenRowCount'),
+    };
+}
+function extractTextFromElement(element) {
+    const r = asRecord(element);
+    const textRun = asRecord(r.textRun);
+    if (Object.keys(textRun).length)
+        return asString(textRun, 'content');
+    const paragraph = asRecord(r.paragraph);
+    if (Object.keys(paragraph).length) {
+        return asArray(paragraph.elements).map(extractTextFromElement).join('') + '\n';
+    }
+    const table = asRecord(r.table);
+    if (Object.keys(table).length) {
+        return asArray(table.tableRows).map(row => {
+            const rowRecord = asRecord(row);
+            return asArray(rowRecord.tableCells).map(cell => {
+                const cellRecord = asRecord(cell);
+                return asArray(cellRecord.content).map(extractTextFromElement).join('').trimEnd();
+            }).join('\t');
+        }).join('\n') + '\n';
+    }
+    const tableCell = asRecord(r.tableCell);
+    if (Object.keys(tableCell).length) {
+        return asArray(tableCell.content).map(extractTextFromElement).join('');
+    }
+    return '';
+}
+function extractDocumentContent(data) {
+    const r = asRecord(data);
+    const tabs = asArray(r.tabs);
+    if (tabs.length) {
+        const mapped = tabs.map(tab => {
+            const tabRecord = asRecord(tab);
+            const tabProps = asRecord(tabRecord.tabProperties);
+            const docTab = asRecord(tabRecord.documentTab);
+            const body = asRecord(docTab.body);
+            const text = asArray(body.content).map(extractTextFromElement).join('').trim();
+            return {
+                tabId: asString(tabProps, 'tabId'),
+                title: asString(tabProps, 'title'),
+                index: asNumber(tabProps, 'index'),
+                textLength: text.length,
+                text,
+            };
+        });
+        return {
+            text: mapped.map(t => t.text).filter(Boolean).join('\n').trim(),
+            tabs: mapped.map(({ text, ...rest }) => rest),
+        };
+    }
+    const body = asRecord(r.body);
+    const text = asArray(body.content).map(extractTextFromElement).join('').trim();
+    return { text, tabs: [] };
+}
+function mapSpreadsheet(data) {
+    const r = asRecord(data);
+    const props = asRecord(r.properties);
+    return {
+        spreadsheetId: asString(r, 'spreadsheetId') || asString(r, 'spreadsheet_id'),
+        title: asString(props, 'title') || asString(r, 'title'),
+        spreadsheetUrl: asString(r, 'spreadsheetUrl'),
+        locale: asString(props, 'locale'),
+        timeZone: asString(props, 'timeZone'),
+        sheetCount: asArray(r.sheets).length,
+        sheets: asArray(r.sheets).map(item => mapSheetProperties(asRecord(item).properties ?? item)),
+    };
+}
+function mapSheetValues(data, spreadsheetId, fallbackRange = '') {
+    const r = asRecord(data);
+    const values = asArray(r.values).map(row => asArray(row).map(cell => cell == null ? '' : String(cell)));
+    return {
+        spreadsheetId,
+        range: asString(r, 'range') || fallbackRange,
+        majorDimension: asString(r, 'majorDimension') || 'ROWS',
+        rowCount: values.length,
+        columnCount: values.reduce((max, row) => Math.max(max, row.length), 0),
+        values,
+    };
+}
+export class GoogleDriveClient {
+    staticToken;
+    clientId;
+    clientSecret;
+    refreshToken;
+    baseUrl;
+    tokenUrl;
+    timeoutMs;
+    fetchImpl;
+    tokenCache = null;
+    constructor(options = {}) {
+        this.staticToken = options.accessToken ?? '';
+        this.clientId = options.clientId ?? '';
+        this.clientSecret = options.clientSecret ?? '';
+        this.refreshToken = options.refreshToken ?? '';
+        this.baseUrl = (options.baseUrl ?? 'https://www.googleapis.com/drive/v3').replace(/\/+$/, '');
+        this.tokenUrl = options.tokenUrl ?? 'https://oauth2.googleapis.com/token';
+        this.timeoutMs = options.timeoutMs ?? 15000;
+        this.fetchImpl = options.fetchImpl ?? globalThis.fetch;
+    }
+    hasCredentials() {
+        return Boolean(this.staticToken || (this.clientId && this.clientSecret && this.refreshToken));
+    }
+    buildUrl(urlOrPath, params) {
+        let url = /^https?:\/\//.test(urlOrPath) ? urlOrPath : `${this.baseUrl}${urlOrPath}`;
+        if (params) {
+            const search = new URLSearchParams();
+            for (const [key, value] of Object.entries(params)) {
+                if (value === undefined || value === '')
+                    continue;
+                if (Array.isArray(value)) {
+                    for (const item of value)
+                        search.append(key, String(item));
+                }
+                else {
+                    search.append(key, String(value));
+                }
+            }
+            const qs = search.toString();
+            if (qs)
+                url += `${url.includes('?') ? '&' : '?'}${qs}`;
+        }
+        return url;
+    }
+    async getAccessToken(signal) {
+        if (this.staticToken)
+            return this.staticToken;
+        if (!this.clientId || !this.clientSecret || !this.refreshToken) {
+            throw new GoogleDriveError('Google Drive credentials not configured.', 401);
+        }
+        if (this.tokenCache && this.tokenCache.expiresAt > Date.now())
+            return this.tokenCache.token;
+        const body = new URLSearchParams({
+            client_id: this.clientId,
+            client_secret: this.clientSecret,
+            refresh_token: this.refreshToken,
+            grant_type: 'refresh_token',
+        });
+        const controller = new AbortController();
+        const combined = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
+        const timer = this.timeoutMs > 0 ? setTimeout(() => controller.abort(), this.timeoutMs) : undefined;
+        try {
+            const response = await this.fetchImpl(this.tokenUrl, {
+                method: 'POST',
+                headers: { 'content-type': 'application/x-www-form-urlencoded' },
+                body: body.toString(),
+                signal: combined,
+            });
+            if (!response.ok) {
+                const text = await response.text().catch(() => '');
+                throw new GoogleDriveError(`Google token endpoint returned HTTP ${response.status}: ${text}`, response.status);
+            }
+            const json = await response.json();
+            const error = typeof json.error === 'string' ? json.error : '';
+            if (error)
+                throw new GoogleDriveError(`Google token endpoint error: ${error}`, 401);
+            const token = asString(json, 'access_token');
+            const expiresIn = asNumber(json, 'expires_in');
+            if (!token)
+                throw new GoogleDriveError('Failed to obtain Google access token.', 401);
+            this.tokenCache = { token, expiresAt: Date.now() + Math.max(60, expiresIn - 60) * 1000 };
+            return token;
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+    async request(method, urlOrPath, options = {}) {
+        const { body, params, auth = true, responseType = 'json', signal } = options;
+        const url = this.buildUrl(urlOrPath, params);
+        const headers = { 'content-type': 'application/json; charset=utf-8' };
+        if (auth)
+            headers.authorization = `Bearer ${await this.getAccessToken(signal)}`;
+        const controller = new AbortController();
+        const combined = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
+        const timer = this.timeoutMs > 0 ? setTimeout(() => controller.abort(), this.timeoutMs) : undefined;
+        try {
+            const response = await this.fetchImpl(url, {
+                method,
+                headers,
+                body: body !== undefined ? JSON.stringify(body) : undefined,
+                signal: combined,
+            });
+            if (!response.ok) {
+                const text = await response.text().catch(() => '');
+                throw new GoogleDriveError(`Google Drive API ${method} ${urlOrPath} returned HTTP ${response.status}: ${text}`, response.status);
+            }
+            if (responseType === 'text')
+                return await response.text();
+            if (responseType === 'arrayBuffer')
+                return await response.arrayBuffer();
+            return await response.json();
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+    async authTest(signal) {
+        const token = await this.getAccessToken(signal);
+        return { ok: true, authMethod: this.staticToken ? 'access_token' : 'refresh_token', tokenPreview: `${token.slice(0, 8)}...` };
+    }
+    async listFiles(options = {}) {
+        const data = asRecord(await this.request('GET', '/files', {
+            params: {
+                q: options.query,
+                pageSize: options.pageSize,
+                pageToken: options.pageToken,
+                orderBy: options.orderBy,
+                spaces: options.spaces,
+                corpora: options.corpora,
+                driveId: options.driveId,
+                includeItemsFromAllDrives: options.includeItemsFromAllDrives,
+                supportsAllDrives: options.supportsAllDrives,
+                fields: 'nextPageToken, incompleteSearch, files(id,name,mimeType,kind,description,iconLink,webViewLink,webContentLink,size,starred,trashed,modifiedTime,createdTime,driveId,parents,owners(displayName,emailAddress))',
+            },
+            signal: options.signal,
+        }));
+        return {
+            items: asArray(data.files).map(mapFile),
+            nextPageToken: asString(data, 'nextPageToken'),
+            incompleteSearch: asBoolean(data, 'incompleteSearch'),
+        };
+    }
+    async getFile(fileId, options = {}) {
+        const data = await this.request('GET', `/files/${encodeURIComponent(fileId)}`, {
+            params: {
+                fields: options.fields ?? 'id,name,mimeType,kind,description,iconLink,webViewLink,webContentLink,size,starred,trashed,modifiedTime,createdTime,driveId,parents,owners(displayName,emailAddress))',
+                supportsAllDrives: options.supportsAllDrives,
+            },
+            signal: options.signal,
+        });
+        return mapFile(data);
+    }
+    async listPermissions(fileId, options = {}) {
+        const data = asRecord(await this.request('GET', '/files/' + encodeURIComponent(fileId) + '/permissions', {
+            params: {
+                pageSize: options.pageSize,
+                pageToken: options.pageToken,
+                supportsAllDrives: options.supportsAllDrives,
+                useDomainAdminAccess: options.useDomainAdminAccess,
+                includePermissionsForView: options.includePermissionsForView,
+                fields: options.fields ?? 'nextPageToken,permissions(id,type,kind,role,emailAddress,displayName,allowFileDiscovery,expirationTime,deleted,permissionDetails)',
+            },
+            signal: options.signal,
+        }));
+        return { fileId, items: asArray(data.permissions).map(mapPermission), nextPageToken: asString(data, 'nextPageToken') };
+    }
+    async listRevisions(fileId, options = {}) {
+        const data = asRecord(await this.request('GET', '/files/' + encodeURIComponent(fileId) + '/revisions', {
+            params: {
+                pageSize: options.pageSize,
+                pageToken: options.pageToken,
+                fields: options.fields ?? 'nextPageToken,revisions(id,mimeType,modifiedTime,keepForever,published,publishAuto,publishedOutsideDomain,size,originalFilename,md5Checksum,downloadUrl,exportLinks)',
+            },
+            signal: options.signal,
+        }));
+        return { fileId, items: asArray(data.revisions).map(mapRevision), nextPageToken: asString(data, 'nextPageToken') };
+    }
+    async exportFile(fileId, options = {}) {
+        const exportMimeType = options.exportMimeType ?? 'text/plain';
+        const responseEncoding = options.responseEncoding ?? 'text';
+        const raw = await this.request('GET', `/files/${encodeURIComponent(fileId)}/export`, {
+            params: {
+                mimeType: exportMimeType,
+                supportsAllDrives: options.supportsAllDrives,
+            },
+            responseType: responseEncoding === 'base64' ? 'arrayBuffer' : 'text',
+            signal: options.signal,
+        });
+        const content = responseEncoding === 'base64'
+            ? Buffer.from(raw).toString('base64')
+            : String(raw);
+        return { fileId, exportMimeType, encoding: responseEncoding, content, contentLength: content.length };
+    }
+    async listSharedDrives(options = {}) {
+        const data = asRecord(await this.request('GET', '/drives', {
+            params: {
+                pageSize: options.pageSize,
+                pageToken: options.pageToken,
+                q: options.query,
+                useDomainAdminAccess: options.useDomainAdminAccess,
+                fields: 'nextPageToken, incompleteSearch, drives(id,name,colorRgb,backgroundImageLink,createdTime,hidden,themeId,capabilities,restrictions)',
+            },
+            signal: options.signal,
+        }));
+        const rawItems = asArray(data.drives).length ? asArray(data.drives) : asArray(data.items);
+        return {
+            items: rawItems.map(mapSharedDrive),
+            nextPageToken: asString(data, 'nextPageToken'),
+            incompleteSearch: asBoolean(data, 'incompleteSearch'),
+        };
+    }
+    async getSharedDrive(driveId, options = {}) {
+        const data = await this.request('GET', `/drives/${encodeURIComponent(driveId)}`, {
+            params: {
+                useDomainAdminAccess: options.useDomainAdminAccess,
+            },
+            signal: options.signal,
+        });
+        return mapSharedDrive(data);
+    }
+    async getDocument(documentId, options = {}) {
+        const data = await this.request('GET', `https://docs.googleapis.com/v1/documents/${encodeURIComponent(documentId)}`, {
+            params: {
+                includeTabsContent: options.includeTabsContent !== false,
+                suggestionsViewMode: options.suggestionsViewMode,
+                commentsViewMode: options.commentsViewMode,
+                fields: options.fields ?? 'documentId,title,revisionId,tabs(tabProperties(tabId,title,index),documentTab(body(content(paragraph(elements(textRun(content))),table(tableRows(tableCells(content(paragraph(elements(textRun(content)))))))))))',
+            },
+            signal: options.signal,
+        });
+        const extracted = extractDocumentContent(data);
+        const r = asRecord(data);
+        return {
+            documentId: asString(r, 'documentId') || documentId,
+            title: asString(r, 'title'),
+            revisionId: asString(r, 'revisionId'),
+            text: extracted.text,
+            tabCount: extracted.tabs.length,
+            tabs: extracted.tabs,
+        };
+    }
+    async getSpreadsheet(spreadsheetId, options = {}) {
+        const data = await this.request('GET', `https://sheets.googleapis.com/v4/spreadsheets/${encodeURIComponent(spreadsheetId)}`, {
+            params: {
+                ranges: options.ranges,
+                includeGridData: options.includeGridData,
+                excludeTablesInBandedRanges: options.excludeTablesInBandedRanges,
+            },
+            signal: options.signal,
+        });
+        return mapSpreadsheet(data);
+    }
+    async getSheetValues(spreadsheetId, range, options = {}) {
+        const data = await this.request('GET', `https://sheets.googleapis.com/v4/spreadsheets/${encodeURIComponent(spreadsheetId)}/values/${encodeURIComponent(range)}`, {
+            params: {
+                valueRenderOption: options.valueRenderOption,
+                dateTimeRenderOption: options.dateTimeRenderOption,
+                majorDimension: options.majorDimension,
+            },
+            signal: options.signal,
+        });
+        return mapSheetValues(data, spreadsheetId, range);
+    }
+}