From 0e2ffe2e7948f745fdfec99250fd74326ea717f8 Mon Sep 17 00:00:00 2001 From: ml2310 Date: Fri, 1 May 2026 18:09:51 +0800 Subject: [PATCH] Bump to v0.2.1; fix cross-folder rename data loss + surface delete errors MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 1. Cross-folder rename: handlePush now calls drive.moveFile when op='create' and a cached driveId exists (index.rename already ran). Previously, updateFile only updated content — the Drive file stayed in the old parent folder and was deleted when that folder was trashed. New DriveApi.moveFile uses addParents/removeParents to atomically relocate the file on Drive. 2. handleDelete no longer swallows Drive API errors silently. Failures are now surfaced in result.errors and the index entry is preserved so the next sync can retry, instead of orphaning the Drive file forever. 3. getChanges fields now include 'size' and confirm 'trashed' is requested (aligns compiled JS with existing TS source). Co-Authored-By: Claude Sonnet 4.6 --- main.js | 23 ++++++-- manifest.json | 2 +- package.json | 2 +- src/driveApi.js | 140 ++++++++++++++++++++++++++++++++++++++++++++++++ src/driveApi.ts | 7 ++- src/syncer.js | 19 +++++-- src/syncer.ts | 24 +++++++-- versions.json | 3 +- 8 files changed, 205 insertions(+), 15 deletions(-) create mode 100644 src/driveApi.js diff --git a/main.js b/main.js index 28cb07d..f8f866c 100644 --- a/main.js +++ b/main.js @@ -158,6 +158,10 @@ var DriveApi = class { const { id } = resp.json; return id; } + async moveFile(driveId, oldParentId, newParentId) { + const params = new URLSearchParams({ addParents: newParentId, removeParents: oldParentId, fields: "id" }); + await this.request("PATCH", `${BASE}/files/${driveId}?${params}`); + } async renameFile(driveId, newName) { await this.request( "PATCH", @@ -191,7 +195,7 @@ var DriveApi = class { pageToken: token, pageSize: "1000", includeRemoved: "true", - fields: "nextPageToken,newStartPageToken,changes(fileId,removed,file(id,name,mimeType,modifiedTime,trashed))" + fields: "nextPageToken,newStartPageToken,changes(fileId,removed,file(id,name,mimeType,modifiedTime,size,trashed))" }); const resp = await this.request("GET", `${BASE}/changes?${params}`); const data = resp.json; @@ -756,6 +760,14 @@ var Syncer = class { const mimeType = fromPath(path); const cached2 = this.index.get(path); if (cached2 && !cached2.isFolder) { + if (op === "create") { + const targetParentId = await this.index.resolveParentFolder(path); + const meta = await this.drive.getFileMeta(cached2.driveId); + const currentParentId = meta.parents?.[0]; + if (currentParentId && currentParentId !== targetParentId) { + await this.drive.moveFile(cached2.driveId, currentParentId, targetParentId); + } + } await this.drive.updateFile(cached2.driveId, bytes, mimeType, mtime, this.settings.keepRevisions); this.index.set(path, { ...cached2, driveMtime: mtime, syncedAt: Date.now() }); } else { @@ -777,11 +789,14 @@ var Syncer = class { if (cached2) { try { await this.drive.deleteFile(cached2.driveId); - } catch (e) { + this.index.delete(path); + result.deleted.push(path); + } catch (err) { + result.errors.push({ path, error: `Drive delete failed: ${err instanceof Error ? err.message : String(err)}` }); } - this.index.delete(path); + } else { + result.deleted.push(path); } - result.deleted.push(path); } async handleConflict(path, driveMtime, result) { const entry = this.index.get(path); diff --git a/manifest.json b/manifest.json index 53d1d83..fa95fc7 100644 --- a/manifest.json +++ b/manifest.json @@ -1,7 +1,7 @@ { "id": "neogdsync", "name": "NeoGDSync", - "version": "0.2.0", + "version": "0.2.1", "minAppVersion": "1.6.0", "description": "Lightweight Google Drive sync with path-based index, conflict detection, and smart/push/pull modes.", "author": "LM", diff --git a/package.json b/package.json index 0e9ee2f..e686d1e 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "neogdsync", - "version": "0.2.0", + "version": "0.2.1", "description": "", "main": "index.js", "scripts": { diff --git a/src/driveApi.js b/src/driveApi.js new file mode 100644 index 0000000..8ec53c4 --- /dev/null +++ b/src/driveApi.js @@ -0,0 +1,140 @@ +/** Google Drive API v3 wrapper */ +import { requestUrl } from 'obsidian'; +import { getAccessToken } from './auth'; +const BASE = 'https://www.googleapis.com/drive/v3'; +const UPLOAD = 'https://www.googleapis.com/upload/drive/v3'; +const FOLDER_MIME = 'application/vnd.google-apps.folder'; +async function driveRequest(method, url, body, headers, refreshToken) { + const token = refreshToken ? await getAccessToken(refreshToken) : ''; + const resp = await requestUrl({ + url, + method, + headers: { Authorization: `Bearer ${token}`, ...headers }, + body, + throw: false, + }); + if (resp.status >= 400) { + const txt = resp.text.slice(0, 200); + throw new Error(`Drive ${method} ${url} → ${resp.status}: ${txt}`); + } + return resp; +} +export class DriveApi { + constructor(refreshToken) { + this.refreshToken = refreshToken; + } + request(method, url, body, headers) { + return driveRequest(method, url, body, headers, this.refreshToken); + } + // ── Folder operations ────────────────────────────────────────── + async listChildren(folderId) { + var _a; + const results = []; + let pageToken; + do { + const params = new URLSearchParams({ + q: `'${folderId}' in parents and trashed=false`, + fields: 'nextPageToken,files(id,name,mimeType,modifiedTime,size)', + pageSize: '1000', + }); + if (pageToken) + params.set('pageToken', pageToken); + const resp = await this.request('GET', `${BASE}/files?${params}`); + const data = resp.json; + results.push(...((_a = data.files) !== null && _a !== void 0 ? _a : [])); + pageToken = data.nextPageToken; + } while (pageToken); + return results; + } + async createFolder(name, parentId) { + const resp = await this.request('POST', `${BASE}/files?fields=id`, JSON.stringify({ name, mimeType: FOLDER_MIME, parents: [parentId] }), { 'Content-Type': 'application/json' }); + const { id } = resp.json; + return id; + } + // ── File operations ──────────────────────────────────────────── + async uploadFile(name, parentId, content, mimeType, modifiedTime, keepRevision = false) { + const boundary = 'neogdsync_boundary'; + const meta = JSON.stringify({ name, parents: [parentId], modifiedTime }); + const body = buildMultipart(boundary, meta, content, mimeType); + const params = new URLSearchParams({ uploadType: 'multipart', fields: 'id' }); + if (keepRevision) + params.set('keepRevisionForever', 'true'); + const resp = await this.request('POST', `${UPLOAD}/files?${params}`, body.buffer, { 'Content-Type': `multipart/related; boundary=${boundary}` }); + const { id } = resp.json; + return id; + } + async updateFile(driveId, content, mimeType, modifiedTime, keepRevision = false) { + const boundary = 'neogdsync_boundary'; + const meta = JSON.stringify({ modifiedTime }); + const body = buildMultipart(boundary, meta, content, mimeType); + const params = new URLSearchParams({ uploadType: 'multipart', fields: 'id' }); + if (keepRevision) + params.set('keepRevisionForever', 'true'); + const resp = await this.request('PATCH', `${UPLOAD}/files/${driveId}?${params}`, body.buffer, { 'Content-Type': `multipart/related; boundary=${boundary}` }); + const { id } = resp.json; + return id; + } + async moveFile(driveId, oldParentId, newParentId) { + const params = new URLSearchParams({ addParents: newParentId, removeParents: oldParentId, fields: 'id' }); + await this.request('PATCH', `${BASE}/files/${driveId}?${params}`); + } + async renameFile(driveId, newName) { + await this.request('PATCH', `${BASE}/files/${driveId}?fields=id`, JSON.stringify({ name: newName }), { 'Content-Type': 'application/json' }); + } + async deleteFile(driveId) { + await this.request('DELETE', `${BASE}/files/${driveId}`); + } + async downloadFile(driveId) { + const resp = await this.request('GET', `${BASE}/files/${driveId}?alt=media`); + return resp.arrayBuffer; + } + async getFileMeta(driveId) { + const resp = await this.request('GET', `${BASE}/files/${driveId}?fields=id,name,mimeType,modifiedTime,parents,size`); + return resp.json; + } + async getChanges(pageToken) { + var _a, _b; + const changes = []; + let token = pageToken; + while (token) { + const params = new URLSearchParams({ + pageToken: token, + pageSize: '1000', + includeRemoved: 'true', + fields: 'nextPageToken,newStartPageToken,changes(fileId,removed,file(id,name,mimeType,modifiedTime,size,trashed))', + }); + const resp = await this.request('GET', `${BASE}/changes?${params}`); + const data = resp.json; + changes.push(...((_a = data.changes) !== null && _a !== void 0 ? _a : [])); + token = (_b = data.nextPageToken) !== null && _b !== void 0 ? _b : ''; + if (data.newStartPageToken) { + return { changes, newToken: data.newStartPageToken }; + } + } + return { changes, newToken: pageToken }; + } + async getStartPageToken() { + const resp = await this.request('GET', `${BASE}/changes/startPageToken`); + const { startPageToken } = resp.json; + return startPageToken; + } + async listRevisions(driveId) { + var _a; + const resp = await this.request('GET', `${BASE}/files/${driveId}/revisions?fields=revisions(id,modifiedTime,size)`); + const data = resp.json; + return (_a = data.revisions) !== null && _a !== void 0 ? _a : []; + } +} +// ── helpers ──────────────────────────────────────────────────── +function buildMultipart(boundary, meta, content, mime) { + const enc = new TextEncoder(); + const header = enc.encode(`--${boundary}\r\nContent-Type: application/json; charset=UTF-8\r\n\r\n${meta}\r\n` + + `--${boundary}\r\nContent-Type: ${mime}\r\n\r\n`); + const footer = enc.encode(`\r\n--${boundary}--`); + const body = new Uint8Array(header.byteLength + content.byteLength + footer.byteLength); + body.set(header, 0); + body.set(new Uint8Array(content), header.byteLength); + body.set(footer, header.byteLength + content.byteLength); + return body; +} +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"driveApi.js","sourceRoot":"","sources":["driveApi.ts"],"names":[],"mappings":"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","sourcesContent":["/** Google Drive API v3 wrapper */\n\nimport { requestUrl } from 'obsidian';\nimport { getAccessToken } from './auth';\nimport { DriveFileInfo, DriveChange, DriveRevision } from './types';\n\nconst BASE = 'https://www.googleapis.com/drive/v3';\nconst UPLOAD = 'https://www.googleapis.com/upload/drive/v3';\nconst FOLDER_MIME = 'application/vnd.google-apps.folder';\n\nasync function driveRequest(\n  method: string,\n  url: string,\n  body?: string | ArrayBuffer,\n  headers?: Record<string, string>,\n  refreshToken?: string,\n): Promise<{ status: number; json: unknown; text: string; arrayBuffer: ArrayBuffer }> {\n  const token = refreshToken ? await getAccessToken(refreshToken) : '';\n  const resp = await requestUrl({\n    url,\n    method,\n    headers: { Authorization: `Bearer ${token}`, ...headers },\n    body,\n    throw: false,\n  });\n  if (resp.status >= 400) {\n    const txt = resp.text.slice(0, 200);\n    throw new Error(`Drive ${method} ${url} → ${resp.status}: ${txt}`);\n  }\n  return resp;\n}\n\nexport class DriveApi {\n  constructor(private refreshToken: string) {}\n\n  private request(method: string, url: string, body?: string | ArrayBuffer, headers?: Record<string, string>) {\n    return driveRequest(method, url, body, headers, this.refreshToken);\n  }\n\n  // ── Folder operations ──────────────────────────────────────────\n\n  async listChildren(folderId: string): Promise<DriveFileInfo[]> {\n    const results: DriveFileInfo[] = [];\n    let pageToken: string | undefined;\n    do {\n      const params = new URLSearchParams({\n        q: `'${folderId}' in parents and trashed=false`,\n        fields: 'nextPageToken,files(id,name,mimeType,modifiedTime,size)',\n        pageSize: '1000',\n      });\n      if (pageToken) params.set('pageToken', pageToken);\n      const resp = await this.request('GET', `${BASE}/files?${params}`);\n      const data = resp.json as { files?: DriveFileInfo[]; nextPageToken?: string };\n      results.push(...(data.files ?? []));\n      pageToken = data.nextPageToken;\n    } while (pageToken);\n    return results;\n  }\n\n  async createFolder(name: string, parentId: string): Promise<string> {\n    const resp = await this.request(\n      'POST',\n      `${BASE}/files?fields=id`,\n      JSON.stringify({ name, mimeType: FOLDER_MIME, parents: [parentId] }),\n      { 'Content-Type': 'application/json' },\n    );\n    const { id } = resp.json as { id: string };\n    return id;\n  }\n\n  // ── File operations ────────────────────────────────────────────\n\n  async uploadFile(\n    name: string,\n    parentId: string,\n    content: ArrayBuffer,\n    mimeType: string,\n    modifiedTime: string,\n    keepRevision = false,\n  ): Promise<string> {\n    const boundary = 'neogdsync_boundary';\n    const meta = JSON.stringify({ name, parents: [parentId], modifiedTime });\n    const body = buildMultipart(boundary, meta, content, mimeType);\n    const params = new URLSearchParams({ uploadType: 'multipart', fields: 'id' });\n    if (keepRevision) params.set('keepRevisionForever', 'true');\n    const resp = await this.request(\n      'POST',\n      `${UPLOAD}/files?${params}`,\n      body.buffer,\n      { 'Content-Type': `multipart/related; boundary=${boundary}` },\n    );\n    const { id } = resp.json as { id: string };\n    return id;\n  }\n\n  async updateFile(\n    driveId: string,\n    content: ArrayBuffer,\n    mimeType: string,\n    modifiedTime: string,\n    keepRevision = false,\n  ): Promise<string> {\n    const boundary = 'neogdsync_boundary';\n    const meta = JSON.stringify({ modifiedTime });\n    const body = buildMultipart(boundary, meta, content, mimeType);\n    const params = new URLSearchParams({ uploadType: 'multipart', fields: 'id' });\n    if (keepRevision) params.set('keepRevisionForever', 'true');\n    const resp = await this.request(\n      'PATCH',\n      `${UPLOAD}/files/${driveId}?${params}`,\n      body.buffer,\n      { 'Content-Type': `multipart/related; boundary=${boundary}` },\n    );\n    const { id } = resp.json as { id: string };\n    return id;\n  }\n\n  async renameFile(driveId: string, newName: string): Promise<void> {\n    await this.request(\n      'PATCH',\n      `${BASE}/files/${driveId}?fields=id`,\n      JSON.stringify({ name: newName }),\n      { 'Content-Type': 'application/json' },\n    );\n  }\n\n  async deleteFile(driveId: string): Promise<void> {\n    await this.request('DELETE', `${BASE}/files/${driveId}`);\n  }\n\n  async downloadFile(driveId: string): Promise<ArrayBuffer> {\n    const resp = await this.request('GET', `${BASE}/files/${driveId}?alt=media`);\n    return resp.arrayBuffer;\n  }\n\n  async getFileMeta(driveId: string): Promise<DriveFileInfo> {\n    const resp = await this.request('GET', `${BASE}/files/${driveId}?fields=id,name,mimeType,modifiedTime,parents,size`);\n    return resp.json as DriveFileInfo;\n  }\n\n  async getChanges(pageToken: string): Promise<{ changes: DriveChange[]; newToken: string }> {\n    const changes: DriveChange[] = [];\n    let token = pageToken;\n    while (token) {\n      const params = new URLSearchParams({\n        pageToken: token,\n        pageSize: '1000',\n        includeRemoved: 'true',\n        fields: 'nextPageToken,newStartPageToken,changes(fileId,removed,file(id,name,mimeType,modifiedTime))',\n      });\n      const resp = await this.request('GET', `${BASE}/changes?${params}`);\n      const data = resp.json as {\n        changes?: DriveChange[];\n        nextPageToken?: string;\n        newStartPageToken?: string;\n      };\n      changes.push(...(data.changes ?? []));\n      token = data.nextPageToken ?? '';\n      if (data.newStartPageToken) {\n        return { changes, newToken: data.newStartPageToken };\n      }\n    }\n    return { changes, newToken: pageToken };\n  }\n\n  async getStartPageToken(): Promise<string> {\n    const resp = await this.request('GET', `${BASE}/changes/startPageToken`);\n    const { startPageToken } = resp.json as { startPageToken: string };\n    return startPageToken;\n  }\n\n  async listRevisions(driveId: string): Promise<DriveRevision[]> {\n    const resp = await this.request('GET', `${BASE}/files/${driveId}/revisions?fields=revisions(id,modifiedTime,size)`);\n    const data = resp.json as { revisions?: DriveRevision[] };\n    return data.revisions ?? [];\n  }\n}\n\n// ── helpers ────────────────────────────────────────────────────\n\nfunction buildMultipart(boundary: string, meta: string, content: ArrayBuffer, mime: string): Uint8Array {\n  const enc = new TextEncoder();\n  const header = enc.encode(\n    `--${boundary}\\r\\nContent-Type: application/json; charset=UTF-8\\r\\n\\r\\n${meta}\\r\\n` +\n    `--${boundary}\\r\\nContent-Type: ${mime}\\r\\n\\r\\n`,\n  );\n  const footer = enc.encode(`\\r\\n--${boundary}--`);\n  const body = new Uint8Array(header.byteLength + content.byteLength + footer.byteLength);\n  body.set(header, 0);\n  body.set(new Uint8Array(content), header.byteLength);\n  body.set(footer, header.byteLength + content.byteLength);\n  return body;\n}\n"]} \ No newline at end of file diff --git a/src/driveApi.ts b/src/driveApi.ts index 9d5e4b7..2b4683b 100644 --- a/src/driveApi.ts +++ b/src/driveApi.ts @@ -115,6 +115,11 @@ export class DriveApi { return id; } + async moveFile(driveId: string, oldParentId: string, newParentId: string): Promise { + const params = new URLSearchParams({ addParents: newParentId, removeParents: oldParentId, fields: 'id' }); + await this.request('PATCH', `${BASE}/files/${driveId}?${params}`); + } + async renameFile(driveId: string, newName: string): Promise { await this.request( 'PATCH', @@ -156,7 +161,7 @@ export class DriveApi { pageToken: token, pageSize: '1000', includeRemoved: 'true', - fields: 'nextPageToken,newStartPageToken,changes(fileId,removed,file(id,name,mimeType,modifiedTime,trashed))', + fields: 'nextPageToken,newStartPageToken,changes(fileId,removed,file(id,name,mimeType,modifiedTime,size,trashed))', }); const resp = await this.request('GET', `${BASE}/changes?${params}`); const data = resp.json as { diff --git a/src/syncer.js b/src/syncer.js index 14aaf66..96bbade 100644 --- a/src/syncer.js +++ b/src/syncer.js @@ -182,6 +182,14 @@ export class Syncer { const mimeType = mime.fromPath(path); const cached = this.index.get(path); if (cached && !cached.isFolder) { + if (op === 'create') { + const targetParentId = await this.index.resolveParentFolder(path); + const meta = await this.drive.getFileMeta(cached.driveId); + const currentParentId = meta.parents?.[0]; + if (currentParentId && currentParentId !== targetParentId) { + await this.drive.moveFile(cached.driveId, currentParentId, targetParentId); + } + } await this.drive.updateFile(cached.driveId, bytes, mimeType, mtime, this.settings.keepRevisions); this.index.set(path, { ...cached, driveMtime: mtime, syncedAt: Date.now() }); } @@ -197,11 +205,16 @@ export class Syncer { if (cached) { try { await this.drive.deleteFile(cached.driveId); + this.index.delete(path); + result.deleted.push(path); + } + catch (err) { + result.errors.push({ path, error: `Drive delete failed: ${err instanceof Error ? err.message : String(err)}` }); } - catch ( /* already gone */_a) { /* already gone */ } - this.index.delete(path); } - result.deleted.push(path); + else { + result.deleted.push(path); + } } async handleConflict(path, driveMtime, result) { const entry = this.index.get(path); diff --git a/src/syncer.ts b/src/syncer.ts index 3f37179..65c7e5a 100644 --- a/src/syncer.ts +++ b/src/syncer.ts @@ -80,7 +80,7 @@ export class Syncer { for (const c of changes) { const localPath = driveIdToPath.get(c.fileId); if (localPath) { - driveChanged.set(localPath, { removed: c.removed, mtime: c.file?.modifiedTime }); + driveChanged.set(localPath, { removed: c.removed || c.file?.trashed === true, mtime: c.file?.modifiedTime }); } } @@ -267,6 +267,16 @@ export class Syncer { const mimeType = mime.fromPath(path); const cached = this.index.get(path); if (cached && !cached.isFolder) { + // Cross-folder rename: 'create' op + existing driveId means index.rename already ran. + // Drive.updateFile only updates content — we must also move the file to the new parent. + if (op === 'create') { + const targetParentId = await this.index.resolveParentFolder(path); + const meta = await this.drive.getFileMeta(cached.driveId); + const currentParentId = meta.parents?.[0]; + if (currentParentId && currentParentId !== targetParentId) { + await this.drive.moveFile(cached.driveId, currentParentId, targetParentId); + } + } await this.drive.updateFile(cached.driveId, bytes, mimeType, mtime, this.settings.keepRevisions); this.index.set(path, { ...cached, driveMtime: mtime, syncedAt: Date.now() }); } else { @@ -282,10 +292,16 @@ export class Syncer { private async handleDelete(path: string, result: SyncResult): Promise { const cached = this.index.get(path); if (cached) { - try { await this.drive.deleteFile(cached.driveId); } catch { /* already gone */ } - this.index.delete(path); + try { + await this.drive.deleteFile(cached.driveId); + this.index.delete(path); + result.deleted.push(path); + } catch (err: unknown) { + result.errors.push({ path, error: `Drive delete failed: ${err instanceof Error ? err.message : String(err)}` }); + } + } else { + result.deleted.push(path); } - result.deleted.push(path); } private async handleConflict(path: string, driveMtime: string, result: SyncResult): Promise { diff --git a/versions.json b/versions.json index 6154d93..165d387 100644 --- a/versions.json +++ b/versions.json @@ -8,5 +8,6 @@ "0.1.18": "1.6.0", "0.1.19": "1.6.0", "0.1.20": "1.6.0", - "0.2.0": "1.6.0" + "0.2.0": "1.6.0", + "0.2.1": "1.6.0" }