@kubun/connector-google-calendar 0.16.0 → 0.17.0

package/lib/actions.js

@@ -1,4 +1,4 @@
-import { createEvent, updateEvent } from './api.js';
+import { createEvent, getCalendar, updateEvent } from './api.js';
 export function createGoogleCalendarActionHandler(config) {
     return {
         async create (_model, params) {
@@ -6,22 +6,51 @@ export function createGoogleCalendarActionHandler(config) {
             if (calendarID == null) {
                 throw new Error('calendarID is required for creating calendar events');
             }
+            // 'primary' is a per-account alias; sync sees the real id. Resolve it once
+            // on create so the composite sourceID matches the synced event's identity.
+            const resolvedCalendarID = calendarID === 'primary' ? (await getCalendar({
+                accessToken: config.credential.accessToken,
+                calendarID: 'primary',
+                fetch: config.fetch
+            })).id : calendarID;
             return createEvent({
                 accessToken: config.credential.accessToken,
-                calendarID,
+                calendarID: resolvedCalendarID,
                 params,
                 fetch: config.fetch
             });
         },
         async update (_model, sourceID, params) {
-            const calendarID = params.calendarID;
-            if (calendarID == null) {
-                throw new Error('calendarID is required for updating calendar events');
+            // sourceID is the composite calendarID/eventID. On a lookup hit the merged
+            // document supplies eventID + calendarID directly; on a miss recover both
+            // from the composite. An eventID never contains '/', a calendarID may, so
+            // split on the last '/'.
+            const mergedEventID = params.eventID;
+            const mergedCalendarID = params.calendarID;
+            let eventID;
+            let calendarID;
+            if (mergedEventID != null) {
+                if (mergedCalendarID == null) {
+                    throw new Error('calendarID is required for updating calendar events');
+                }
+                eventID = mergedEventID;
+                calendarID = mergedCalendarID;
+            } else {
+                const slash = sourceID.lastIndexOf('/');
+                if (slash <= 0 || slash === sourceID.length - 1) {
+                    throw new Error(`Cannot recover eventID from sourceID "${sourceID}"`);
+                }
+                const recoveredCalendarID = sourceID.slice(0, slash);
+                if (mergedCalendarID != null && mergedCalendarID !== recoveredCalendarID) {
+                    throw new Error('calendarID does not match the event sourceID');
+                }
+                eventID = sourceID.slice(slash + 1);
+                calendarID = recoveredCalendarID;
             }
             return updateEvent({
                 accessToken: config.credential.accessToken,
                 calendarID,
-                eventID: sourceID,
+                eventID,
                 params,
                 fetch: config.fetch
             });

package/lib/api.d.ts

@@ -49,7 +49,20 @@ export declare function buildEventsListURL(params: {
 }): string;
 export declare function mapCalendarToEntity(calendar: GoogleCalendarResource): EntityRecord;
 export declare function mapEventToEntity(event: GoogleEventResource, calendarID: string): EntityRecord;
-export declare function buildEventFromParams(params: Record<string, unknown>): Record<string, unknown>;
+export declare function buildEventFromParams(params: Record<string, unknown>, options?: {
+    create?: boolean;
+}): Record<string, unknown>;
+export declare function getCalendar(config: {
+    accessToken: string;
+    calendarID: string;
+    fetch?: typeof globalThis.fetch;
+}): Promise<GoogleCalendarResource>;
+export declare function getEvent(config: {
+    accessToken: string;
+    calendarID: string;
+    eventID: string;
+    fetch?: typeof globalThis.fetch;
+}): Promise<EntityRecord>;
 export declare function createEvent(config: {
     accessToken: string;
     calendarID: string;

package/lib/api.js

@@ -61,7 +61,11 @@ export function mapEventToEntity(event, calendarID) {
     const endAt = allDay ? allDayDateToDateTime(event.end.date) : event.end.dateTime;
     return {
         sourceService: 'google-calendar',
-        sourceID: event.id,
+        // Google event ids are unique per calendar, not per account; namespace the
+        // identity by calendar so the same id in two calendars stays two documents.
+        // The bare id lives on in eventID for PATCH targeting.
+        sourceID: `${calendarID}/${event.id}`,
+        eventID: event.id,
         sourceURL: event.htmlLink,
         title: event.summary ?? '(No title)',
         description: event.description,
@@ -80,9 +84,15 @@ export function mapEventToEntity(event, calendarID) {
         }
     };
 }
-export function buildEventFromParams(params) {
+export function buildEventFromParams(params, options) {
     const event = {};
     const allDay = params.allDay === true;
+    // A caller-supplied id makes a create idempotent (Google rejects a duplicate
+    // with 409). Only insert accepts an id; PATCH must never carry one, so gate it
+    // to the create path — the builder is shared with updateEvent.
+    if (options?.create === true && params.id != null) {
+        event.id = params.id;
+    }
     if (params.title != null) {
         event.summary = params.title;
     }
@@ -93,8 +103,11 @@ export function buildEventFromParams(params) {
         event.location = params.location;
     }
     if (params.startAt != null) {
+        // An imported all-day event carries startAt as a midnight-UTC timestamp
+        // (mapEventToEntity anchors bare dates for the date-time schema); slice back
+        // to YYYY-MM-DD, which Google requires for start.date/end.date.
         event.start = allDay ? {
-            date: params.startAt
+            date: params.startAt.slice(0, 10)
         } : {
             dateTime: params.startAt,
             ...params.timeZone != null ? {
@@ -104,7 +117,7 @@ export function buildEventFromParams(params) {
     }
     if (params.endAt != null) {
         event.end = allDay ? {
-            date: params.endAt
+            date: params.endAt.slice(0, 10)
         } : {
             dateTime: params.endAt,
             ...params.timeZone != null ? {
@@ -114,9 +127,40 @@ export function buildEventFromParams(params) {
     }
     return event;
 }
+export async function getCalendar(config) {
+    const fetchFn = config.fetch ?? globalThis.fetch;
+    const url = `${CALENDAR_BASE_URL}/calendars/${encodeURIComponent(config.calendarID)}`;
+    const response = await fetchFn(url, {
+        headers: {
+            Authorization: `Bearer ${config.accessToken}`
+        }
+    });
+    if (!response.ok) {
+        const errorMessage = await parseGoogleError(response);
+        throw new Error(`Google Calendar API error: ${errorMessage}`);
+    }
+    return await response.json();
+}
+export async function getEvent(config) {
+    const fetchFn = config.fetch ?? globalThis.fetch;
+    const url = `${CALENDAR_BASE_URL}/calendars/${encodeURIComponent(config.calendarID)}/events/${encodeURIComponent(config.eventID)}`;
+    const response = await fetchFn(url, {
+        headers: {
+            Authorization: `Bearer ${config.accessToken}`
+        }
+    });
+    if (!response.ok) {
+        const errorMessage = await parseGoogleError(response);
+        throw new Error(`Google Calendar API error: ${errorMessage}`);
+    }
+    const data = await response.json();
+    return mapEventToEntity(data, config.calendarID);
+}
 export async function createEvent(config) {
     const fetchFn = config.fetch ?? globalThis.fetch;
-    const event = buildEventFromParams(config.params);
+    const event = buildEventFromParams(config.params, {
+        create: true
+    });
     const url = `${CALENDAR_BASE_URL}/calendars/${encodeURIComponent(config.calendarID)}/events`;
     const response = await fetchFn(url, {
         method: 'POST',
@@ -127,6 +171,17 @@ export async function createEvent(config) {
         body: JSON.stringify(event)
     });
     if (!response.ok) {
+        // A 409 on a caller-supplied id means the event already exists — the create
+        // is already committed, so a retry after a lost response is idempotent: fetch
+        // and return the existing event instead of failing.
+        if (response.status === 409 && config.params.id != null) {
+            return getEvent({
+                accessToken: config.accessToken,
+                calendarID: config.calendarID,
+                eventID: config.params.id,
+                fetch: config.fetch
+            });
+        }
         const errorMessage = await parseGoogleError(response);
         throw new Error(`Google Calendar API error: ${errorMessage}`);
     }

package/lib/model.d.ts

@@ -98,6 +98,9 @@ export declare const googleCalendarEventDefinition: {
             readonly recurringEventID: {
                 readonly type: "string";
             };
+            readonly eventID: {
+                readonly type: "string";
+            };
             readonly calendarID: {
                 readonly type: "string";
             };
@@ -130,7 +133,7 @@ export declare const googleCalendarEventDefinition: {
                 readonly type: "string";
                 readonly title: "SourceID";
                 readonly minLength: 1;
-                readonly maxLength: 500;
+                readonly maxLength: 1400;
             };
             readonly SourceURL: {
                 readonly type: "string";

package/lib/model.js

@@ -108,6 +108,9 @@ export const googleCalendarEventDefinition = {
             recurringEventID: {
                 type: 'string'
             },
+            eventID: {
+                type: 'string'
+            },
             calendarID: {
                 type: 'string'
             },
@@ -145,11 +148,13 @@ export const googleCalendarEventDefinition = {
                 minLength: 1,
                 maxLength: 50
             },
+            // A composite calendarID/eventID: calendar id (email-like, up to ~254) +
+            // '/' + a Google event id (up to 1024). 500 is too small.
             SourceID: {
                 type: 'string',
                 title: 'SourceID',
                 minLength: 1,
-                maxLength: 500
+                maxLength: 1400
             },
             SourceURL: urlSchema,
             DateTime: dateTimeSchema,

package/lib/provider.js

@@ -31,7 +31,9 @@ function computeTimeMin(boundary) {
     // Parse PnD format (e.g. "P30D" = 30 days)
     const match = /^P(\d+)D$/i.exec(boundary.maxAge);
     if (match == null) return undefined;
-    const days = Number.parseInt(match[1], 10);
+    const rawDays = match[1];
+    if (rawDays == null) return undefined;
+    const days = Number.parseInt(rawDays, 10);
     const date = new Date();
     date.setDate(date.getDate() - days);
     return date.toISOString();
@@ -104,8 +106,7 @@ export function createGoogleCalendarProvider(config) {
         // Phase 2: fetch events per calendar
         const calendarTokens = {};
         let eventBatchYielded = false;
-        for(let i = 0; i < allCalendars.length; i++){
-            const calendar = allCalendars[i];
+        for (const [i, calendar] of allCalendars.entries()){
             const isLastCalendar = i === allCalendars.length - 1;
             let eventsSyncToken;
             for await (const page of fetchEventsForCalendar({
@@ -135,9 +136,11 @@ export function createGoogleCalendarProvider(config) {
                 yield {
                     modelID: CALENDAR_EVENT_MODEL_ID,
                     entities: activeItems.map((event)=>mapEventToEntity(event, calendar.id)),
+                    // Match the composite identity mapEventToEntity assigns, so the
+                    // tombstone lookup hits the calendar-namespaced document.
                     deleted: cancelledItems.map((e)=>({
                             sourceService: 'google-calendar',
-                            sourceID: e.id
+                            sourceID: `${calendar.id}/${e.id}`
                         })),
                     hasMore: !(isLastCalendar && isLastPage),
                     checkpoint
@@ -220,8 +223,8 @@ export function createGoogleCalendarProvider(config) {
                 }))
         ];
         const updatedCalendarTokens = {};
-        for(let i = 0; i < allCalendarIDsToSync.length; i++){
-            const { id: calendarID, isNew } = allCalendarIDsToSync[i];
+        for (const [i, entry] of allCalendarIDsToSync.entries()){
+            const { id: calendarID, isNew } = entry;
             const isLastCalendar = i === allCalendarIDsToSync.length - 1;
             // Use stored syncToken for known calendars; use timeMin for new ones
             const storedToken = isNew ? undefined : prevCalendarTokens[calendarID]?.eventsSyncToken;
@@ -253,9 +256,11 @@ export function createGoogleCalendarProvider(config) {
                 yield {
                     modelID: CALENDAR_EVENT_MODEL_ID,
                     entities: activeItems.map((event)=>mapEventToEntity(event, calendarID)),
+                    // Match the composite identity mapEventToEntity assigns, so the
+                    // tombstone lookup hits the calendar-namespaced document.
                     deleted: cancelledItems.map((e)=>({
                             sourceService: 'google-calendar',
-                            sourceID: e.id
+                            sourceID: `${calendarID}/${e.id}`
                         })),
                     hasMore: !(isLastCalendar && isLastPage),
                     checkpoint: newCheckpoint

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubun/connector-google-calendar",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "keywords": [],
   "license": "see LICENSE.md",
   "sideEffects": false,
@@ -15,12 +15,12 @@
     "LICENSE.md"
   ],
   "dependencies": {
-    "@kubun/connector": "^0.16.0",
-    "@kubun/credential-types": "^0.16.0",
-    "@kubun/models": "^0.16.0",
-    "@kubun/protocol": "^0.16.0",
-    "@kubun/provider-google": "^0.16.0",
-    "@kubun/scalars": "^0.16.0"
+    "@kubun/connector": "^0.17.0",
+    "@kubun/credential-types": "^0.17.0",
+    "@kubun/models": "^0.17.0",
+    "@kubun/protocol": "^0.17.0",
+    "@kubun/provider-google": "^0.17.0",
+    "@kubun/scalars": "^0.17.0"
   },
   "publishConfig": {
     "access": "public"
@@ -28,8 +28,8 @@
   "scripts": {
     "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
     "build:clean": "del lib",
-    "build:js": "swc src -d ./lib --config-file ../../node_modules/@kigu/dev/swc.json --strip-leading-paths",
-    "build:types": "tsc --emitDeclarationOnly --skipLibCheck",
+    "build:js": "del 'lib/**/*.js' && swc src -d ./lib --config-file ../../node_modules/@kigu/dev/swc.json --strip-leading-paths",
+    "build:types": "del 'lib/**/*.d.ts' 'lib/**/*.d.ts.map' && tsc --emitDeclarationOnly --skipLibCheck",
     "build:types:ci": "tsc --emitDeclarationOnly --declarationMap false",
     "test": "pnpm run test:types && pnpm run test:unit",
     "test:types": "tsc --noEmit -p tsconfig.test.json",