@kubun/connector-google-calendar 0.17.0 → 0.17.2

package/lib/index.d.ts

@@ -1,5 +1,10 @@
 export { createGoogleCalendarActionHandler, type GoogleCalendarActionHandlerConfig, } from './actions.js';
 export { buildCalendarListURL, buildEventFromParams, buildEventsListURL, createEvent, type GoogleCalendarListResponse, type GoogleCalendarResource, type GoogleEventDateTime, type GoogleEventResource, type GoogleEventsListResponse, mapCalendarToEntity, mapEventToEntity, updateEvent, } from './api.js';
 export { type CreateGoogleCalendarConnectorOptions, createGoogleCalendarConnector, } from './connector.js';
+export { GoogleCalendarAPIError, GoogleCalendarError, type GoogleCalendarErrorCode, type GoogleCalendarErrorOptions, GoogleCalendarEventConflict, } from './errors.js';
+export { deriveEventID } from './event-id.js';
+export { canonicalizeEventIntent, eventHoldsIntent } from './intent.js';
 export { googleCalendarClusters, googleCalendarDefinition, googleCalendarEventDefinition, } from './model.js';
+export { predictCreatedEventSourceID } from './predict.js';
 export { type CalendarCheckpoint, createGoogleCalendarProvider, type GoogleCalendarProviderConfig, } from './provider.js';
+export { resolveCalendarTarget } from './target.js';

package/lib/index.js

@@ -1,5 +1,10 @@
 export { createGoogleCalendarActionHandler } from './actions.js';
 export { buildCalendarListURL, buildEventFromParams, buildEventsListURL, createEvent, mapCalendarToEntity, mapEventToEntity, updateEvent } from './api.js';
 export { createGoogleCalendarConnector } from './connector.js';
+export { GoogleCalendarAPIError, GoogleCalendarError, GoogleCalendarEventConflict } from './errors.js';
+export { deriveEventID } from './event-id.js';
+export { canonicalizeEventIntent, eventHoldsIntent } from './intent.js';
 export { googleCalendarClusters, googleCalendarDefinition, googleCalendarEventDefinition } from './model.js';
+export { predictCreatedEventSourceID } from './predict.js';
 export { createGoogleCalendarProvider } from './provider.js';
+export { resolveCalendarTarget } from './target.js';

package/lib/intent.d.ts

@@ -0,0 +1,23 @@
+import type { EntityRecord, IntentCanonicalizer } from '@kubun/connector';
+/**
+ * The Calendar intent canonicalizer (see `IntentCanonicalizer`). Folds in only
+ * what Google itself does to a written event:
+ * - a start/end is compared as the instant (or, all-day, the date) it names,
+ *   only when it names one by itself (an explicit offset), and an all-day
+ *   value never matches a timed one;
+ * - `calendarID` is compared exactly: an operation's intent already carries
+ *   the calendar the `'primary'` alias was resolved to before the claim;
+ * - a cancelled (deleted) event holds no create or update.
+ */
+export declare const canonicalizeEventIntent: IntentCanonicalizer;
+/**
+ * Whether a Calendar event holds a write's intent: every event field the
+ * intent sets carries the intended value, as Google keeps it. Keys of the
+ * intent that are not event fields (a target, say) are not compared, and an
+ * intent that sets no event field does not hold.
+ */
+export declare function eventHoldsIntent(params: {
+    op: 'create' | 'update';
+    intent: Record<string, unknown>;
+    record: EntityRecord;
+}): boolean;

package/lib/intent.js

@@ -0,0 +1,86 @@
+import { digestJSON } from '@kubun/id';
+import { toB64U } from '@sozai/codec';
+import { googleCalendarEventDefinition } from './model.js';
+const EVENT_FIELDS = new Set(googleCalendarEventDefinition.providerMergePolicy.group);
+const BARE_DATE = /^\d{4}-\d{2}-\d{2}$/;
+const DATE_PREFIX = /^\d{4}-\d{2}-\d{2}/;
+// A date-time that names its instant by itself: an explicit `Z` or `±hh:mm`.
+const WITH_OFFSET = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:\d{2})$/i;
+// A start/end in the form Google keeps it. An all-day value is its calendar
+// date (Google stores only the date) — kept a string, so it never equals a
+// timed instant. A timed value with an explicit offset is the instant it names
+// (Google re-renders a dateTime in the calendar's offset). Anything else — an
+// offset-less date-time, which would otherwise be read in the host's time
+// zone — stays as it is and is compared exactly.
+function canonicalDateTime(value, allDay) {
+    if (typeof value !== 'string') return value;
+    if (allDay) return DATE_PREFIX.test(value) ? value.slice(0, 10) : value;
+    return WITH_OFFSET.test(value) ? Date.parse(value) : value;
+}
+/**
+ * The Calendar intent canonicalizer (see `IntentCanonicalizer`). Folds in only
+ * what Google itself does to a written event:
+ * - a start/end is compared as the instant (or, all-day, the date) it names,
+ *   only when it names one by itself (an explicit offset), and an all-day
+ *   value never matches a timed one;
+ * - `calendarID` is compared exactly: an operation's intent already carries
+ *   the calendar the `'primary'` alias was resolved to before the claim;
+ * - a cancelled (deleted) event holds no create or update.
+ */ export const canonicalizeEventIntent = ({ model, intent, record })=>{
+    if (model !== googleCalendarEventDefinition.name) return {
+        intent,
+        record
+    };
+    if (record.status === 'CANCELLED') return null;
+    // Each side is read in its own shape: an all-day intent (declared, or a
+    // bare date) as dates, the record by its own allDay flag. A timed intent
+    // against an all-day event, or the reverse, therefore never compares equal.
+    const intentAllDay = intent.allDay === true;
+    const recordAllDay = record.allDay === true;
+    const canonicalIntent = {
+        ...intent
+    };
+    const canonicalRecord = {
+        ...record
+    };
+    for (const field of [
+        'startAt',
+        'endAt'
+    ]){
+        if (field in canonicalIntent) {
+            const value = canonicalIntent[field];
+            const asDate = intentAllDay || typeof value === 'string' && BARE_DATE.test(value);
+            canonicalIntent[field] = canonicalDateTime(value, asDate);
+        }
+        canonicalRecord[field] = canonicalDateTime(canonicalRecord[field], recordAllDay);
+    }
+    return {
+        intent: canonicalIntent,
+        record: canonicalRecord
+    };
+};
+function canonicalOf(value) {
+    return toB64U(digestJSON(value === undefined ? null : value));
+}
+// An intent that sets no event field confirms nothing, and does not hold.
+function holds(compared) {
+    let matched = 0;
+    for (const [field, intended] of Object.entries(compared.intent)){
+        if (!EVENT_FIELDS.has(field)) continue;
+        if (canonicalOf(compared.record[field]) !== canonicalOf(intended)) return false;
+        matched++;
+    }
+    return matched > 0;
+}
+/**
+ * Whether a Calendar event holds a write's intent: every event field the
+ * intent sets carries the intended value, as Google keeps it. Keys of the
+ * intent that are not event fields (a target, say) are not compared, and an
+ * intent that sets no event field does not hold.
+ */ export function eventHoldsIntent(params) {
+    const compared = canonicalizeEventIntent({
+        model: googleCalendarEventDefinition.name,
+        ...params
+    });
+    return compared != null && holds(compared);
+}

package/lib/model.d.ts

@@ -20,6 +20,11 @@ export declare const googleCalendarDefinition: {
             readonly backgroundColor: {
                 readonly type: "string";
             };
+            readonly accountKey: {
+                readonly type: "string";
+                readonly minLength: 43;
+                readonly maxLength: 43;
+            };
             readonly sourceService: {
                 readonly $ref: "#/definitions/SourceService";
             };
@@ -104,6 +109,9 @@ export declare const googleCalendarEventDefinition: {
             readonly calendarID: {
                 readonly type: "string";
             };
+            readonly etag: {
+                readonly type: "string";
+            };
             readonly calendar: {
                 readonly $ref: "#/definitions/CalendarDocID";
             };
@@ -165,5 +173,8 @@ export declare const googleCalendarEventDefinition: {
             readonly model: "#0";
         };
     };
+    readonly providerMergePolicy: {
+        readonly group: ["title", "startAt", "endAt", "allDay", "timeZone", "description", "location", "status", "htmlLink", "recurringEventID", "eventID", "calendarID", "calendar", "sourceService", "sourceID", "sourceURL", "etag"];
+    };
 };
 export declare const googleCalendarClusters: import("@kubun/protocol").ClustersRecord;

package/lib/model.js

@@ -26,6 +26,11 @@ export const googleCalendarDefinition = {
             backgroundColor: {
                 type: 'string'
             },
+            accountKey: {
+                type: 'string',
+                minLength: 43,
+                maxLength: 43
+            },
             sourceService: {
                 $ref: '#/definitions/SourceService'
             },
@@ -114,6 +119,9 @@ export const googleCalendarEventDefinition = {
             calendarID: {
                 type: 'string'
             },
+            etag: {
+                type: 'string'
+            },
             calendar: {
                 $ref: '#/definitions/CalendarDocID'
             },
@@ -177,6 +185,32 @@ export const googleCalendarEventDefinition = {
             type: 'document',
             model: '#0'
         }
+    },
+    // lastSyncedAt is a device-local sync-bookkeeping annotation, not fetched
+    // provider content, so it stays outside the group.
+    providerMergePolicy: {
+        group: [
+            'title',
+            'startAt',
+            'endAt',
+            'allDay',
+            'timeZone',
+            'description',
+            'location',
+            'status',
+            'htmlLink',
+            'recurringEventID',
+            'eventID',
+            'calendarID',
+            'calendar',
+            'sourceService',
+            'sourceID',
+            'sourceURL',
+            // The provider revision of this state: an update is written
+            // conditionally on it (If-Match), so it must travel with the fields it
+            // versions.
+            'etag'
+        ]
     }
 };
 const builder = new GraphBuilder({

package/lib/predict.d.ts

@@ -0,0 +1,8 @@
+import type { CreatedSourceIDPredictor } from '@kubun/connector';
+/**
+ * The provider id a calendar event create is stored under: the resolved
+ * calendar and the event id derived from the operation's deterministic event
+ * id, as the create handler inserts it. `null` for a calendar create and for
+ * an input whose calendar is not resolved.
+ */
+export declare const predictCreatedEventSourceID: CreatedSourceIDPredictor;

package/lib/predict.js

@@ -0,0 +1,12 @@
+import { deriveEventID } from './event-id.js';
+/**
+ * The provider id a calendar event create is stored under: the resolved
+ * calendar and the event id derived from the operation's deterministic event
+ * id, as the create handler inserts it. `null` for a calendar create and for
+ * an input whose calendar is not resolved.
+ */ export const predictCreatedEventSourceID = ({ model, input, deterministicEventID })=>{
+    if (model !== 'GoogleCalendarEvent') return null;
+    const calendarID = input.calendarID;
+    if (typeof calendarID !== 'string' || calendarID === '' || calendarID === 'primary') return null;
+    return `${calendarID}/${deriveEventID(deterministicEventID)}`;
+};

package/lib/provider.d.ts

@@ -5,11 +5,13 @@ export type GoogleCalendarProviderConfig = {
     boundary?: SyncBoundary;
     fetch?: typeof globalThis.fetch;
     excludeCalendars?: Array<string>;
+    mintFetchHLC: () => string;
 };
 export type CalendarCheckpoint = {
     calendarListSyncToken?: string;
     calendars: Record<string, {
         eventsSyncToken?: string;
     }>;
+    windowStart?: string;
 };
 export declare function createGoogleCalendarProvider(config: GoogleCalendarProviderConfig): ServerDataProvider;

package/lib/provider.js

@@ -1,19 +1,10 @@
 import { resolveModelID } from '@kubun/connector';
-import { buildCalendarListURL, buildEventsListURL, mapCalendarToEntity, mapEventToEntity, parseGoogleError } from './api.js';
+import { deriveAccountKey } from './account-key.js';
+import { buildCalendarListURL, buildEventsListURL, getCalendarListEntry, getEvent, getEventWithETag, mapCalendarToEntity, mapEventToEntity, parseGoogleError, splitEventSourceID } from './api.js';
+import { GoogleCalendarAPIError } from './errors.js';
 import { googleCalendarClusters } from './model.js';
 const CALENDAR_MODEL_ID = resolveModelID(googleCalendarClusters, 'GoogleCalendar');
 const CALENDAR_EVENT_MODEL_ID = resolveModelID(googleCalendarClusters, 'GoogleCalendarEvent');
-class GoogleCalendarAPIError extends Error {
-    #status;
-    constructor(status, detail){
-        super(`Google Calendar API error: ${detail}`);
-        this.name = 'GoogleCalendarAPIError';
-        this.#status = status;
-    }
-    get status() {
-        return this.#status;
-    }
-}
 async function fetchJSON(url, credential, fetchFn, signal) {
     const response = await fetchFn(url, {
         headers: {
@@ -78,8 +69,24 @@ async function* fetchEventsForCalendar(params) {
 export function createGoogleCalendarProvider(config) {
     const fetchFn = config.fetch ?? globalThis.fetch;
     const excludeSet = new Set(config.excludeCalendars ?? []);
+    const mintFetchHLC = config.mintFetchHLC;
+    // Derived once per provider instance — a pure function of (iss,sub), so it is
+    // stable across refresh and re-auth. Absent when the credential predates
+    // providerAccount capture.
+    const accountKey = config.credential.providerAccount != null ? deriveAccountKey(config.credential.providerAccount) : undefined;
+    // getCalendarListEntry/getEvent/getEventWithETag (api.ts) throw a plain Error tagged
+    // with `.httpStatus` (googleAPIError) — this is the seam fetchEntity/reconcile
+    // use to turn a 404 into a `present: false` result instead of a throw.
+    function isNotFound(err) {
+        return err?.httpStatus === 404;
+    }
     async function* fetchAllEntities(params) {
-        const timeMin = computeTimeMin(params.boundary);
+        // Reuse a window frozen by a prior sync (carried in an expired checkpoint on
+        // the 410 resync path, or a re-driven initial) instead of recomputing from
+        // `now`; only a genuine first sync computes it fresh.
+        const prior = params.checkpoint;
+        const windowStart = prior?.windowStart ?? computeTimeMin(params.boundary);
+        const timeMin = windowStart;
         // Phase 1: fetch all calendars (collect all pages first, then yield single batch)
         const allCalendars = [];
         let calendarListSyncToken;
@@ -98,9 +105,14 @@ export function createGoogleCalendarProvider(config) {
             }
         }
         // Yield calendar batch (no checkpoint yet — will be on the last event batch)
+        const calendarListToken = mintFetchHLC();
         yield {
             modelID: CALENDAR_MODEL_ID,
-            entities: allCalendars.map(mapCalendarToEntity),
+            entities: allCalendars.map((c)=>({
+                    present: true,
+                    record: mapCalendarToEntity(c, accountKey),
+                    sourceFetchHLC: calendarListToken
+                })),
             hasMore: true
         };
         // Phase 2: fetch events per calendar
@@ -128,19 +140,28 @@ export function createGoogleCalendarProvider(config) {
                         [calendar.id]: {
                             eventsSyncToken: page.nextSyncToken
                         }
-                    }
+                    },
+                    ...windowStart != null ? {
+                        windowStart
+                    } : {}
                 } : undefined;
                 // Split items: cancelled → deleted, others → entities
                 const activeItems = page.items.filter((e)=>e.status !== 'cancelled');
                 const cancelledItems = page.items.filter((e)=>e.status === 'cancelled');
+                const pageToken = mintFetchHLC();
                 yield {
                     modelID: CALENDAR_EVENT_MODEL_ID,
-                    entities: activeItems.map((event)=>mapEventToEntity(event, calendar.id)),
+                    entities: activeItems.map((event)=>({
+                            present: true,
+                            record: mapEventToEntity(event, calendar.id),
+                            sourceFetchHLC: pageToken
+                        })),
                     // Match the composite identity mapEventToEntity assigns, so the
                     // tombstone lookup hits the calendar-namespaced document.
                     deleted: cancelledItems.map((e)=>({
-                            sourceService: 'google-calendar',
-                            sourceID: `${calendar.id}/${e.id}`
+                            present: false,
+                            sourceID: `${calendar.id}/${e.id}`,
+                            sourceFetchHLC: pageToken
                         })),
                     hasMore: !(isLastCalendar && isLastPage),
                     checkpoint
@@ -160,13 +181,18 @@ export function createGoogleCalendarProvider(config) {
                 hasMore: false,
                 checkpoint: {
                     calendarListSyncToken,
-                    calendars: calendarTokens
+                    calendars: calendarTokens,
+                    ...windowStart != null ? {
+                        windowStart
+                    } : {}
                 }
             };
         }
     }
     async function* fetchIncrementalEntities(params, checkpoint) {
-        const timeMin = computeTimeMin(params.boundary);
+        // Carry the frozen window forward; new calendars are floored by it (not `now`).
+        const windowStart = checkpoint.windowStart ?? computeTimeMin(params.boundary);
+        const timeMin = windowStart;
         // Phase 1: fetch calendar list changes using stored syncToken
         const activeCalendars = [];
         const deletedCalendarIDs = [];
@@ -189,12 +215,18 @@ export function createGoogleCalendarProvider(config) {
             }
         }
         // Yield calendar batch (active + deletions)
+        const calendarListToken = mintFetchHLC();
         yield {
             modelID: CALENDAR_MODEL_ID,
-            entities: activeCalendars.map(mapCalendarToEntity),
+            entities: activeCalendars.map((c)=>({
+                    present: true,
+                    record: mapCalendarToEntity(c, accountKey),
+                    sourceFetchHLC: calendarListToken
+                })),
             deleted: deletedCalendarIDs.map((id)=>({
-                    sourceService: 'google-calendar',
-                    sourceID: id
+                    present: false,
+                    sourceID: id,
+                    sourceFetchHLC: calendarListToken
                 })),
             hasMore: true
         };
@@ -248,19 +280,28 @@ export function createGoogleCalendarProvider(config) {
                         [calendarID]: {
                             eventsSyncToken: page.nextSyncToken
                         }
-                    }
+                    },
+                    ...windowStart != null ? {
+                        windowStart
+                    } : {}
                 } : undefined;
                 // Split items: cancelled → deleted, others → entities
                 const activeItems = page.items.filter((e)=>e.status !== 'cancelled');
                 const cancelledItems = page.items.filter((e)=>e.status === 'cancelled');
+                const pageToken = mintFetchHLC();
                 yield {
                     modelID: CALENDAR_EVENT_MODEL_ID,
-                    entities: activeItems.map((event)=>mapEventToEntity(event, calendarID)),
+                    entities: activeItems.map((event)=>({
+                            present: true,
+                            record: mapEventToEntity(event, calendarID),
+                            sourceFetchHLC: pageToken
+                        })),
                     // Match the composite identity mapEventToEntity assigns, so the
                     // tombstone lookup hits the calendar-namespaced document.
                     deleted: cancelledItems.map((e)=>({
-                            sourceService: 'google-calendar',
-                            sourceID: `${calendarID}/${e.id}`
+                            present: false,
+                            sourceID: `${calendarID}/${e.id}`,
+                            sourceFetchHLC: pageToken
                         })),
                     hasMore: !(isLastCalendar && isLastPage),
                     checkpoint: newCheckpoint
@@ -279,16 +320,109 @@ export function createGoogleCalendarProvider(config) {
                 hasMore: false,
                 checkpoint: {
                     calendarListSyncToken: newCalendarListSyncToken,
-                    calendars: updatedCalendarTokens
+                    calendars: updatedCalendarTokens,
+                    ...windowStart != null ? {
+                        windowStart
+                    } : {}
                 }
             };
         }
     }
+    // Targeted single-entity fetch (anti-entropy repair verification). Mints its
+    // own fetch-order token at request start, independent of any batch token
+    // (see ServerProviderFactory.mintFetchHLC's doc). `model` distinguishes the
+    // account-level GoogleCalendar resource from a GoogleCalendarEvent — only
+    // the latter's sourceID is the composite calendarID/eventID.
+    async function fetchEntity(model, sourceID) {
+        const sourceFetchHLC = mintFetchHLC();
+        try {
+            if (model === CALENDAR_MODEL_ID) {
+                const calendar = await getCalendarListEntry({
+                    accessToken: config.credential.accessToken,
+                    calendarID: sourceID,
+                    fetch: fetchFn
+                });
+                return {
+                    present: true,
+                    record: mapCalendarToEntity(calendar, accountKey),
+                    sourceFetchHLC
+                };
+            }
+            const { calendarID, eventID } = splitEventSourceID(sourceID);
+            const record = await getEvent({
+                accessToken: config.credential.accessToken,
+                calendarID,
+                eventID,
+                fetch: fetchFn
+            });
+            return {
+                present: true,
+                record,
+                sourceFetchHLC
+            };
+        } catch (err) {
+            if (isNotFound(err)) {
+                return {
+                    present: false,
+                    sourceID,
+                    sourceFetchHLC
+                };
+            }
+            throw err;
+        }
+    }
+    // Provider-authoritative re-read for write-back recovery. Unlike
+    // fetchEntity, the present:true branch also surfaces a providerETag when the
+    // provider reports one — the current revision an update's If-Match can
+    // condition on.
+    async function reconcile(model, sourceID) {
+        const sourceFetchHLC = mintFetchHLC();
+        try {
+            if (model === CALENDAR_MODEL_ID) {
+                const calendar = await getCalendarListEntry({
+                    accessToken: config.credential.accessToken,
+                    calendarID: sourceID,
+                    fetch: fetchFn
+                });
+                return {
+                    present: true,
+                    record: mapCalendarToEntity(calendar, accountKey),
+                    sourceFetchHLC
+                };
+            }
+            const { calendarID, eventID } = splitEventSourceID(sourceID);
+            const { record, etag } = await getEventWithETag({
+                accessToken: config.credential.accessToken,
+                calendarID,
+                eventID,
+                fetch: fetchFn
+            });
+            return {
+                present: true,
+                record,
+                sourceFetchHLC,
+                ...etag != null ? {
+                    providerETag: etag
+                } : {}
+            };
+        } catch (err) {
+            if (isNotFound(err)) {
+                return {
+                    present: false,
+                    sourceID,
+                    sourceFetchHLC
+                };
+            }
+            throw err;
+        }
+    }
     return {
         supportedStrategies: [
             'on-demand'
         ],
         fetchAll: fetchAllEntities,
+        fetchEntity,
+        reconcile,
         async *fetchChanges (params) {
             const checkpoint = params.checkpoint;
             if (checkpoint == null) {

package/lib/target.d.ts

@@ -0,0 +1,11 @@
+import type { ActionTargetResolver } from '@kubun/connector';
+/**
+ * The Calendar target resolver (see `ActionTargetResolver`): a write's target
+ * is the calendar it lands in.
+ * - A create targets the `calendarID` of its input, required.
+ * - An update targets the calendar of its event (the `calendarID/eventID`
+ *   sourceID); a `calendarID` in its input must name that same calendar.
+ * - The `'primary'` alias is resolved to the account's synced primary
+ *   calendar, and the input carries the resolved id from then on.
+ */
+export declare const resolveCalendarTarget: ActionTargetResolver;

package/lib/target.js

@@ -0,0 +1,68 @@
+import { deriveAccountKey } from './account-key.js';
+import { splitEventSourceID } from './api.js';
+import { GoogleCalendarError } from './errors.js';
+import { googleCalendarDefinition } from './model.js';
+function calendarError(code, message) {
+    return new GoogleCalendarError(`${code}: ${message}`, {
+        code,
+        kind: 'rejected'
+    });
+}
+// The account's primary calendar, as synced to this device: the calendar-list
+// entry Google flags primary, under this account. Never a provider call —
+// before the calendars are synced there is nothing to resolve it to.
+async function syncedPrimaryCalendar(storage, providerAccount) {
+    const accountKey = deriveAccountKey(providerAccount);
+    const primary = (await storage.documents(googleCalendarDefinition.name)).filter((calendar)=>calendar.primary === true && calendar.accountKey === accountKey);
+    const [only] = primary;
+    if (primary.length !== 1 || typeof only?.sourceID !== 'string') {
+        throw calendarError('GOOGLE_CALENDARS_NOT_SYNCED', primary.length === 0 ? 'the primary calendar is not known on this device yet; sync calendars first' : 'more than one synced calendar is flagged primary for this account; sync calendars again');
+    }
+    return only.sourceID;
+}
+/**
+ * The Calendar target resolver (see `ActionTargetResolver`): a write's target
+ * is the calendar it lands in.
+ * - A create targets the `calendarID` of its input, required.
+ * - An update targets the calendar of its event (the `calendarID/eventID`
+ *   sourceID); a `calendarID` in its input must name that same calendar.
+ * - The `'primary'` alias is resolved to the account's synced primary
+ *   calendar, and the input carries the resolved id from then on.
+ */ export const resolveCalendarTarget = async ({ op, input, sourceID, providerAccount, storage })=>{
+    const named = input.calendarID;
+    const resolveNamed = async ()=>{
+        if (named == null) return undefined;
+        if (typeof named !== 'string' || named === '') {
+            throw calendarError('GOOGLE_CALENDAR_ID_REQUIRED', 'calendarID must be a calendar id');
+        }
+        return named === 'primary' ? await syncedPrimaryCalendar(storage, providerAccount) : named;
+    };
+    if (op === 'create') {
+        const calendarID = await resolveNamed();
+        if (calendarID == null) {
+            throw calendarError('GOOGLE_CALENDAR_ID_REQUIRED', 'a new event needs a calendarID');
+        }
+        return {
+            target: calendarID,
+            input: {
+                ...input,
+                calendarID
+            }
+        };
+    }
+    if (sourceID == null) {
+        throw calendarError('GOOGLE_CALENDAR_ID_REQUIRED', 'an event update needs its sourceID');
+    }
+    const eventCalendarID = splitEventSourceID(sourceID).calendarID;
+    const calendarID = await resolveNamed();
+    if (calendarID != null && calendarID !== eventCalendarID) {
+        throw calendarError('GOOGLE_CALENDAR_ID_MISMATCH', `calendarID does not name the calendar of the event "${sourceID}"`);
+    }
+    return {
+        target: eventCalendarID,
+        input: calendarID != null ? {
+            ...input,
+            calendarID
+        } : input
+    };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubun/connector-google-calendar",
-  "version": "0.17.0",
+  "version": "0.17.2",
   "keywords": [],
   "license": "see LICENSE.md",
   "sideEffects": false,
@@ -15,12 +15,18 @@
     "LICENSE.md"
   ],
   "dependencies": {
-    "@kubun/connector": "^0.17.0",
-    "@kubun/credential-types": "^0.17.0",
+    "@kubun/connector": "^0.17.2",
+    "@kubun/credential-types": "^0.17.2",
+    "@kubun/hlc": "^0.17.0",
+    "@kubun/id": "^0.17.0",
     "@kubun/models": "^0.17.0",
-    "@kubun/protocol": "^0.17.0",
+    "@kubun/protocol": "^0.17.1",
     "@kubun/provider-google": "^0.17.0",
-    "@kubun/scalars": "^0.17.0"
+    "@kubun/scalars": "^0.17.0",
+    "@sozai/codec": "^0.4.0"
+  },
+  "devDependencies": {
+    "@sozai/schema": "^0.1.2"
   },
   "publishConfig": {
     "access": "public"