@kubun/connector-google-calendar 0.10.0 → 0.12.0

package/lib/actions.js

@@ -1 +1,30 @@
-import{createEvent as e,updateEvent as r}from"./api.js";export function createGoogleCalendarActionHandler(a){return{async create(r,n){let c=n.calendarID;if(null==c)throw Error("calendarID is required for creating calendar events");return e({accessToken:a.credential.accessToken,calendarID:c,params:n,fetch:a.fetch})},async update(e,n,c){let t=c.calendarID;if(null==t)throw Error("calendarID is required for updating calendar events");return r({accessToken:a.credential.accessToken,calendarID:t,eventID:n,params:c,fetch:a.fetch})}}}
+import { createEvent, updateEvent } from './api.js';
+export function createGoogleCalendarActionHandler(config) {
+    return {
+        async create (_model, params) {
+            const calendarID = params.calendarID;
+            if (calendarID == null) {
+                throw new Error('calendarID is required for creating calendar events');
+            }
+            return createEvent({
+                accessToken: config.credential.accessToken,
+                calendarID,
+                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');
+            }
+            return updateEvent({
+                accessToken: config.credential.accessToken,
+                calendarID,
+                eventID: sourceID,
+                params,
+                fetch: config.fetch
+            });
+        }
+    };
+}

package/lib/api.js

@@ -1 +1,142 @@
-let e="https://www.googleapis.com/calendar/v3";async function t(e){try{let t=await e.json();return t.error?.message??`${e.status} ${e.statusText}`}catch{return`${e.status} ${e.statusText}`}}export function buildCalendarListURL(t){let n=new URL(`${e}/users/me/calendarList`);return n.searchParams.set("showHidden","false"),null!=t.syncToken&&n.searchParams.set("syncToken",t.syncToken),null!=t.pageToken&&n.searchParams.set("pageToken",t.pageToken),n.toString()}export function buildEventsListURL(t){let n=new URL(`${e}/calendars/${encodeURIComponent(t.calendarID)}/events`);return n.searchParams.set("singleEvents","true"),null!=t.syncToken?n.searchParams.set("syncToken",t.syncToken):null!=t.timeMin&&n.searchParams.set("timeMin",t.timeMin),null!=t.pageToken&&n.searchParams.set("pageToken",t.pageToken),n.toString()}export function mapCalendarToEntity(e){return{sourceService:"google-calendar",sourceID:e.id,sourceURL:"https://calendar.google.com",summary:e.summary,description:e.description,timeZone:e.timeZone,primary:e.primary??!1,backgroundColor:e.backgroundColor}}export function mapEventToEntity(e,t){let n=null!=e.start.date,a=n?e.start.date:e.start.dateTime,r=n?e.end.date:e.end.dateTime;return{sourceService:"google-calendar",sourceID:e.id,sourceURL:e.htmlLink,title:e.summary??"(No title)",description:e.description,location:e.location,allDay:n,startAt:a,endAt:r,status:e.status.toUpperCase(),htmlLink:e.htmlLink,recurringEventID:e.recurringEventID,timeZone:e.start.timeZone,calendarID:t,calendar:{sourceService:"google-calendar",sourceID:t}}}export function buildEventFromParams(e){let t={},n=!0===e.allDay;return null!=e.title&&(t.summary=e.title),null!=e.description&&(t.description=e.description),null!=e.location&&(t.location=e.location),null!=e.startAt&&(t.start=n?{date:e.startAt}:{dateTime:e.startAt,...null!=e.timeZone?{timeZone:e.timeZone}:{}}),null!=e.endAt&&(t.end=n?{date:e.endAt}:{dateTime:e.endAt,...null!=e.timeZone?{timeZone:e.timeZone}:{}}),t}export async function createEvent(n){let a=n.fetch??globalThis.fetch,r=buildEventFromParams(n.params),o=`${e}/calendars/${encodeURIComponent(n.calendarID)}/events`,s=await a(o,{method:"POST",headers:{Authorization:`Bearer ${n.accessToken}`,"Content-Type":"application/json"},body:JSON.stringify(r)});if(!s.ok){let e=await t(s);throw Error(`Google Calendar API error: ${e}`)}return mapEventToEntity(await s.json(),n.calendarID)}export async function updateEvent(n){let a=n.fetch??globalThis.fetch,r=buildEventFromParams(n.params),o=`${e}/calendars/${encodeURIComponent(n.calendarID)}/events/${encodeURIComponent(n.eventID)}`,s=await a(o,{method:"PATCH",headers:{Authorization:`Bearer ${n.accessToken}`,"Content-Type":"application/json"},body:JSON.stringify(r)});if(!s.ok){let e=await t(s);throw Error(`Google Calendar API error: ${e}`)}return mapEventToEntity(await s.json(),n.calendarID)}
+const CALENDAR_BASE_URL = 'https://www.googleapis.com/calendar/v3';
+async function parseGoogleError(response) {
+    try {
+        const body = await response.json();
+        return body.error?.message ?? `${response.status} ${response.statusText}`;
+    } catch  {
+        return `${response.status} ${response.statusText}`;
+    }
+}
+export function buildCalendarListURL(params) {
+    const url = new URL(`${CALENDAR_BASE_URL}/users/me/calendarList`);
+    url.searchParams.set('showHidden', 'false');
+    if (params.syncToken != null) {
+        url.searchParams.set('syncToken', params.syncToken);
+    }
+    if (params.pageToken != null) {
+        url.searchParams.set('pageToken', params.pageToken);
+    }
+    return url.toString();
+}
+export function buildEventsListURL(params) {
+    const url = new URL(`${CALENDAR_BASE_URL}/calendars/${encodeURIComponent(params.calendarID)}/events`);
+    url.searchParams.set('singleEvents', 'true');
+    if (params.syncToken != null) {
+        url.searchParams.set('syncToken', params.syncToken);
+    } else if (params.timeMin != null) {
+        url.searchParams.set('timeMin', params.timeMin);
+    }
+    if (params.pageToken != null) {
+        url.searchParams.set('pageToken', params.pageToken);
+    }
+    return url.toString();
+}
+export function mapCalendarToEntity(calendar) {
+    return {
+        sourceService: 'google-calendar',
+        sourceID: calendar.id,
+        sourceURL: 'https://calendar.google.com',
+        summary: calendar.summary,
+        description: calendar.description,
+        timeZone: calendar.timeZone,
+        primary: calendar.primary ?? false,
+        backgroundColor: calendar.backgroundColor
+    };
+}
+export function mapEventToEntity(event, calendarID) {
+    const allDay = event.start.date != null;
+    const startAt = allDay ? event.start.date : event.start.dateTime;
+    const endAt = allDay ? event.end.date : event.end.dateTime;
+    return {
+        sourceService: 'google-calendar',
+        sourceID: event.id,
+        sourceURL: event.htmlLink,
+        title: event.summary ?? '(No title)',
+        description: event.description,
+        location: event.location,
+        allDay,
+        startAt,
+        endAt,
+        status: event.status.toUpperCase(),
+        htmlLink: event.htmlLink,
+        recurringEventID: event.recurringEventID,
+        timeZone: event.start.timeZone,
+        calendarID,
+        calendar: {
+            sourceService: 'google-calendar',
+            sourceID: calendarID
+        }
+    };
+}
+export function buildEventFromParams(params) {
+    const event = {};
+    const allDay = params.allDay === true;
+    if (params.title != null) {
+        event.summary = params.title;
+    }
+    if (params.description != null) {
+        event.description = params.description;
+    }
+    if (params.location != null) {
+        event.location = params.location;
+    }
+    if (params.startAt != null) {
+        event.start = allDay ? {
+            date: params.startAt
+        } : {
+            dateTime: params.startAt,
+            ...params.timeZone != null ? {
+                timeZone: params.timeZone
+            } : {}
+        };
+    }
+    if (params.endAt != null) {
+        event.end = allDay ? {
+            date: params.endAt
+        } : {
+            dateTime: params.endAt,
+            ...params.timeZone != null ? {
+                timeZone: params.timeZone
+            } : {}
+        };
+    }
+    return event;
+}
+export async function createEvent(config) {
+    const fetchFn = config.fetch ?? globalThis.fetch;
+    const event = buildEventFromParams(config.params);
+    const url = `${CALENDAR_BASE_URL}/calendars/${encodeURIComponent(config.calendarID)}/events`;
+    const response = await fetchFn(url, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${config.accessToken}`,
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(event)
+    });
+    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 updateEvent(config) {
+    const fetchFn = config.fetch ?? globalThis.fetch;
+    const event = buildEventFromParams(config.params);
+    const url = `${CALENDAR_BASE_URL}/calendars/${encodeURIComponent(config.calendarID)}/events/${encodeURIComponent(config.eventID)}`;
+    const response = await fetchFn(url, {
+        method: 'PATCH',
+        headers: {
+            Authorization: `Bearer ${config.accessToken}`,
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(event)
+    });
+    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);
+}

package/lib/connector.js

@@ -1 +1,105 @@
-import{createGoogleCalendarActionHandler as e}from"./actions.js";import{googleCalendarClusters as t}from"./model.js";import{createGoogleCalendarProvider as r}from"./provider.js";export function createGoogleCalendarConnector(n){return{name:"google-calendar",version:"1.0.0",clusters:t,syncStrategies:["on-demand"],actions:[{name:"create",description:"Create a Google Calendar event",input:{type:"object",properties:{calendarID:{type:"string"},title:{type:"string"},startAt:{type:"string"},endAt:{type:"string"},allDay:{type:"boolean"},description:{type:"string"},location:{type:"string"},timeZone:{type:"string"}}},requiresCredential:!0},{name:"update",description:"Update a Google Calendar event",input:{type:"object",properties:{calendarID:{type:"string"},title:{type:"string"},startAt:{type:"string"},endAt:{type:"string"},allDay:{type:"boolean"},description:{type:"string"},location:{type:"string"},timeZone:{type:"string"}}},requiresCredential:!0}],actionHandler:t=>e({credential:t.credential,fetch:n?.fetch}),auth:{provider:"google",scopes:["https://www.googleapis.com/auth/calendar.readonly"],writeScopes:["https://www.googleapis.com/auth/calendar"]},serverProvider:e=>r({credential:e.credential,boundary:e.boundary,fetch:n?.fetch})}}
+import { createGoogleCalendarActionHandler } from './actions.js';
+import { googleCalendarClusters } from './model.js';
+import { createGoogleCalendarProvider } from './provider.js';
+export function createGoogleCalendarConnector(options) {
+    return {
+        name: 'google-calendar',
+        version: '1.0.0',
+        clusters: googleCalendarClusters,
+        syncStrategies: [
+            'on-demand'
+        ],
+        actions: [
+            {
+                name: 'create',
+                description: 'Create a Google Calendar event',
+                input: {
+                    type: 'object',
+                    properties: {
+                        calendarID: {
+                            type: 'string'
+                        },
+                        title: {
+                            type: 'string'
+                        },
+                        startAt: {
+                            type: 'string'
+                        },
+                        endAt: {
+                            type: 'string'
+                        },
+                        allDay: {
+                            type: 'boolean'
+                        },
+                        description: {
+                            type: 'string'
+                        },
+                        location: {
+                            type: 'string'
+                        },
+                        timeZone: {
+                            type: 'string'
+                        }
+                    }
+                },
+                requiresCredential: true
+            },
+            {
+                name: 'update',
+                description: 'Update a Google Calendar event',
+                input: {
+                    type: 'object',
+                    properties: {
+                        calendarID: {
+                            type: 'string'
+                        },
+                        title: {
+                            type: 'string'
+                        },
+                        startAt: {
+                            type: 'string'
+                        },
+                        endAt: {
+                            type: 'string'
+                        },
+                        allDay: {
+                            type: 'boolean'
+                        },
+                        description: {
+                            type: 'string'
+                        },
+                        location: {
+                            type: 'string'
+                        },
+                        timeZone: {
+                            type: 'string'
+                        }
+                    }
+                },
+                requiresCredential: true
+            }
+        ],
+        actionHandler: (config)=>{
+            return createGoogleCalendarActionHandler({
+                credential: config.credential,
+                fetch: options?.fetch
+            });
+        },
+        auth: {
+            provider: 'google',
+            scopes: [
+                'https://www.googleapis.com/auth/calendar.readonly'
+            ],
+            writeScopes: [
+                'https://www.googleapis.com/auth/calendar'
+            ]
+        },
+        serverProvider: (config)=>{
+            return createGoogleCalendarProvider({
+                credential: config.credential,
+                boundary: config.boundary,
+                fetch: options?.fetch
+            });
+        }
+    };
+}

package/lib/index.js

@@ -1 +1,5 @@
-export{createGoogleCalendarActionHandler}from"./actions.js";export{buildCalendarListURL,buildEventFromParams,buildEventsListURL,createEvent,mapCalendarToEntity,mapEventToEntity,updateEvent}from"./api.js";export{createGoogleCalendarConnector}from"./connector.js";export{googleCalendarClusters,googleCalendarDefinition,googleCalendarEventDefinition}from"./model.js";export{createGoogleCalendarProvider}from"./provider.js";
+export { createGoogleCalendarActionHandler } from './actions.js';
+export { buildCalendarListURL, buildEventFromParams, buildEventsListURL, createEvent, mapCalendarToEntity, mapEventToEntity, updateEvent } from './api.js';
+export { createGoogleCalendarConnector } from './connector.js';
+export { googleCalendarClusters, googleCalendarDefinition, googleCalendarEventDefinition } from './model.js';
+export { createGoogleCalendarProvider } from './provider.js';

package/lib/model.js

@@ -1 +1,185 @@
-import{connectorClusters as e,connectorModelIDs as t}from"@kubun/connector";import{modelIDs as i,modelsClusters as n}from"@kubun/models";import{GraphBuilder as r}from"@kubun/protocol";import{dateTimeSchema as o,docIDSchema as a,timeZoneSchema as s,urlSchema as c}from"@kubun/scalars";export const googleCalendarDefinition={name:"GoogleCalendar",behavior:"default",interfaces:[t.ExternalEntity],schema:{type:"object",properties:{summary:{type:"string"},description:{type:"string"},timeZone:{$ref:"#/definitions/TimeZone"},primary:{type:"boolean"},backgroundColor:{type:"string"},sourceService:{$ref:"#/definitions/SourceService"},sourceID:{$ref:"#/definitions/SourceID"},sourceURL:{$ref:"#/definitions/SourceURL"},lastSyncedAt:{$ref:"#/definitions/DateTime"}},required:["summary","sourceService","sourceID","lastSyncedAt"],additionalProperties:!1,definitions:{SourceService:{type:"string",title:"SourceService",minLength:1,maxLength:50},SourceID:{type:"string",title:"SourceID",minLength:1,maxLength:500},SourceURL:c,DateTime:o,TimeZone:s}},fieldsMeta:{}};export const googleCalendarEventDefinition={name:"GoogleCalendarEvent",behavior:"default",interfaces:[t.ExternalEntity,i.EventKind],schema:{type:"object",properties:{title:{type:"string",minLength:1,maxLength:200},startAt:{$ref:"#/definitions/DateTime"},endAt:{$ref:"#/definitions/DateTime"},allDay:{type:"boolean"},timeZone:{$ref:"#/definitions/TimeZone"},description:{type:"string"},location:{type:"string"},status:{$ref:"#/definitions/EventStatus"},htmlLink:{$ref:"#/definitions/HtmlLink"},recurringEventID:{type:"string"},calendarID:{type:"string"},calendar:{$ref:"#/definitions/CalendarDocID"},sourceService:{$ref:"#/definitions/SourceService"},sourceID:{$ref:"#/definitions/SourceID"},sourceURL:{$ref:"#/definitions/SourceURL"},lastSyncedAt:{$ref:"#/definitions/DateTime"}},required:["title","startAt","allDay","calendarID","calendar","sourceService","sourceID","lastSyncedAt"],additionalProperties:!1,definitions:{SourceService:{type:"string",title:"SourceService",minLength:1,maxLength:50},SourceID:{type:"string",title:"SourceID",minLength:1,maxLength:500},SourceURL:c,DateTime:o,TimeZone:s,HtmlLink:c,CalendarDocID:a,EventStatus:{type:"string",title:"EventStatus",enum:["CONFIRMED","TENTATIVE","CANCELLED"]}}},fieldsMeta:{calendar:{type:"document",model:"#0"}}};let l=new r({externalClusters:{...e,...n}});l.add(googleCalendarDefinition),l.add(googleCalendarEventDefinition);export const googleCalendarClusters=l.build();
+import { connectorClusters, connectorModelIDs } from '@kubun/connector';
+import { modelIDs, modelsClusters } from '@kubun/models';
+import { GraphBuilder } from '@kubun/protocol';
+import { dateTimeSchema, docIDSchema, timeZoneSchema, urlSchema } from '@kubun/scalars';
+export const googleCalendarDefinition = {
+    name: 'GoogleCalendar',
+    behavior: 'default',
+    interfaces: [
+        connectorModelIDs.ExternalEntity
+    ],
+    schema: {
+        type: 'object',
+        properties: {
+            summary: {
+                type: 'string'
+            },
+            description: {
+                type: 'string'
+            },
+            timeZone: {
+                $ref: '#/definitions/TimeZone'
+            },
+            primary: {
+                type: 'boolean'
+            },
+            backgroundColor: {
+                type: 'string'
+            },
+            sourceService: {
+                $ref: '#/definitions/SourceService'
+            },
+            sourceID: {
+                $ref: '#/definitions/SourceID'
+            },
+            sourceURL: {
+                $ref: '#/definitions/SourceURL'
+            },
+            lastSyncedAt: {
+                $ref: '#/definitions/DateTime'
+            }
+        },
+        required: [
+            'summary',
+            'sourceService',
+            'sourceID',
+            'lastSyncedAt'
+        ],
+        additionalProperties: false,
+        definitions: {
+            SourceService: {
+                type: 'string',
+                title: 'SourceService',
+                minLength: 1,
+                maxLength: 50
+            },
+            SourceID: {
+                type: 'string',
+                title: 'SourceID',
+                minLength: 1,
+                maxLength: 500
+            },
+            SourceURL: urlSchema,
+            DateTime: dateTimeSchema,
+            TimeZone: timeZoneSchema
+        }
+    },
+    fieldsMeta: {}
+};
+export const googleCalendarEventDefinition = {
+    name: 'GoogleCalendarEvent',
+    behavior: 'default',
+    interfaces: [
+        connectorModelIDs.ExternalEntity,
+        modelIDs.EventKind
+    ],
+    schema: {
+        type: 'object',
+        properties: {
+            title: {
+                type: 'string',
+                minLength: 1,
+                maxLength: 200
+            },
+            startAt: {
+                $ref: '#/definitions/DateTime'
+            },
+            endAt: {
+                $ref: '#/definitions/DateTime'
+            },
+            allDay: {
+                type: 'boolean'
+            },
+            timeZone: {
+                $ref: '#/definitions/TimeZone'
+            },
+            description: {
+                type: 'string'
+            },
+            location: {
+                type: 'string'
+            },
+            status: {
+                $ref: '#/definitions/EventStatus'
+            },
+            htmlLink: {
+                $ref: '#/definitions/HtmlLink'
+            },
+            recurringEventID: {
+                type: 'string'
+            },
+            calendarID: {
+                type: 'string'
+            },
+            calendar: {
+                $ref: '#/definitions/CalendarDocID'
+            },
+            sourceService: {
+                $ref: '#/definitions/SourceService'
+            },
+            sourceID: {
+                $ref: '#/definitions/SourceID'
+            },
+            sourceURL: {
+                $ref: '#/definitions/SourceURL'
+            },
+            lastSyncedAt: {
+                $ref: '#/definitions/DateTime'
+            }
+        },
+        required: [
+            'title',
+            'startAt',
+            'allDay',
+            'calendarID',
+            'calendar',
+            'sourceService',
+            'sourceID',
+            'lastSyncedAt'
+        ],
+        additionalProperties: false,
+        definitions: {
+            SourceService: {
+                type: 'string',
+                title: 'SourceService',
+                minLength: 1,
+                maxLength: 50
+            },
+            SourceID: {
+                type: 'string',
+                title: 'SourceID',
+                minLength: 1,
+                maxLength: 500
+            },
+            SourceURL: urlSchema,
+            DateTime: dateTimeSchema,
+            TimeZone: timeZoneSchema,
+            HtmlLink: urlSchema,
+            CalendarDocID: docIDSchema,
+            EventStatus: {
+                type: 'string',
+                title: 'EventStatus',
+                enum: [
+                    'CONFIRMED',
+                    'TENTATIVE',
+                    'CANCELLED'
+                ]
+            }
+        }
+    },
+    fieldsMeta: {
+        calendar: {
+            type: 'document',
+            model: '#0'
+        }
+    }
+};
+const builder = new GraphBuilder({
+    externalClusters: {
+        ...connectorClusters,
+        ...modelsClusters
+    }
+});
+builder.add(googleCalendarDefinition); // #0
+builder.add(googleCalendarEventDefinition); // #1
+export const googleCalendarClusters = builder.build();

package/lib/provider.js

@@ -1 +1,282 @@
-import{resolveModelID as e}from"@kubun/connector";import{buildCalendarListURL as n,buildEventsListURL as t,mapCalendarToEntity as l,mapEventToEntity as a}from"./api.js";import{googleCalendarClusters as i}from"./model.js";let o=e(i,"GoogleCalendar"),c=e(i,"GoogleCalendarEvent");async function r(e,n,t,l){let a=await t(e,{headers:{Authorization:`Bearer ${n.accessToken}`},signal:l});if(!a.ok)throw Error(`Google Calendar API error: ${a.status} ${a.statusText}`);return await a.json()}function s(e){if(null==e.maxAge)return;let n=/^P(\d+)D$/i.exec(e.maxAge);if(null==n)return;let t=Number.parseInt(n[1],10),l=new Date;return l.setDate(l.getDate()-t),l.toISOString()}async function*d(e){let t,l=!0;do{let a=n({syncToken:l?e.syncToken:void 0,pageToken:t}),i=await r(a,e.credential,e.fetchFn,e.signal);yield{items:i.items??[],nextSyncToken:i.nextSyncToken,isFirstPage:l},t=i.nextPageToken,l=!1}while(null!=t)}async function*u(e){let n,l=!0;do{let a=t({calendarID:e.calendarID,syncToken:l?e.syncToken:void 0,pageToken:n,timeMin:e.timeMin}),i=await r(a,e.credential,e.fetchFn,e.signal);yield{items:i.items??[],nextSyncToken:i.nextSyncToken},n=i.nextPageToken,l=!1}while(null!=n)}export function createGoogleCalendarProvider(e){let n=e.fetch??globalThis.fetch,t=new Set(e.excludeCalendars??[]);async function*i(i){let r,y=s(i.boundary),f=[];for await(let l of d({credential:e.credential,fetchFn:n,signal:i.signal})){for(let e of l.items)t.has(e.id)||f.push(e);null!=l.nextSyncToken&&(r=l.nextSyncToken)}yield{modelID:o,entities:f.map(l),hasMore:!0};let m={},k=!1;for(let t=0;t<f.length;t++){let l,o=f[t],s=t===f.length-1;for await(let t of u({calendarID:o.id,credential:e.credential,fetchFn:n,timeMin:y,signal:i.signal})){null!=t.nextSyncToken&&(l=t.nextSyncToken);let e=null!=t.nextSyncToken,n=s&&e?{calendarListSyncToken:r,calendars:{...m,[o.id]:{eventsSyncToken:t.nextSyncToken}}}:void 0,i=t.items.filter(e=>"cancelled"!==e.status),d=t.items.filter(e=>"cancelled"===e.status);yield{modelID:c,entities:i.map(e=>a(e,o.id)),deleted:d.map(e=>({sourceService:"google-calendar",sourceID:e.id})),hasMore:!(s&&e),checkpoint:n},k=!0}m[o.id]={eventsSyncToken:l}}k||(yield{modelID:c,entities:[],hasMore:!1,checkpoint:{calendarListSyncToken:r,calendars:m}})}return{supportedStrategies:["on-demand"],fetchAll:i,async *fetchChanges(r){let y,f=r.checkpoint;if(null==f)return void(yield*i(r));let m=s(r.boundary),k=[],g=[];for await(let l of d({credential:e.credential,fetchFn:n,syncToken:f.calendarListSyncToken,signal:r.signal})){for(let e of l.items)!0===e.deleted?g.push(e.id):t.has(e.id)||k.push(e);null!=l.nextSyncToken&&(y=l.nextSyncToken)}yield{modelID:o,entities:k.map(l),deleted:g.map(e=>({sourceService:"google-calendar",sourceID:e})),hasMore:!0};let h={...f.calendars};for(let e of g)delete h[e];let T=k.filter(e=>!(e.id in f.calendars)),S=[...Object.keys(h).map(e=>({id:e,isNew:!1})),...T.map(e=>({id:e.id,isNew:!0}))],p={};for(let t=0;t<S.length;t++){let l,{id:i,isNew:o}=S[t],s=t===S.length-1,d=o?void 0:h[i]?.eventsSyncToken;for await(let t of u({calendarID:i,credential:e.credential,fetchFn:n,syncToken:d,timeMin:o?m:void 0,signal:r.signal})){null!=t.nextSyncToken&&(l=t.nextSyncToken);let e=null!=t.nextSyncToken,n=s&&e?{calendarListSyncToken:y,calendars:{...p,[i]:{eventsSyncToken:t.nextSyncToken}}}:void 0,o=t.items.filter(e=>"cancelled"!==e.status),r=t.items.filter(e=>"cancelled"===e.status);yield{modelID:c,entities:o.map(e=>a(e,i)),deleted:r.map(e=>({sourceService:"google-calendar",sourceID:e.id})),hasMore:!(s&&e),checkpoint:n}}p[i]={eventsSyncToken:l}}0===S.length&&(yield{modelID:c,entities:[],hasMore:!1,checkpoint:{calendarListSyncToken:y,calendars:p}})}}}
+import { resolveModelID } from '@kubun/connector';
+import { buildCalendarListURL, buildEventsListURL, mapCalendarToEntity, mapEventToEntity } from './api.js';
+import { googleCalendarClusters } from './model.js';
+const CALENDAR_MODEL_ID = resolveModelID(googleCalendarClusters, 'GoogleCalendar');
+const CALENDAR_EVENT_MODEL_ID = resolveModelID(googleCalendarClusters, 'GoogleCalendarEvent');
+async function fetchJSON(url, credential, fetchFn, signal) {
+    const response = await fetchFn(url, {
+        headers: {
+            Authorization: `Bearer ${credential.accessToken}`
+        },
+        signal
+    });
+    if (!response.ok) {
+        throw new Error(`Google Calendar API error: ${response.status} ${response.statusText}`);
+    }
+    return await response.json();
+}
+function computeTimeMin(boundary) {
+    if (boundary.maxAge == null) return undefined;
+    // 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 date = new Date();
+    date.setDate(date.getDate() - days);
+    return date.toISOString();
+}
+async function* fetchAllCalendars(params) {
+    let pageToken;
+    let isFirstPage = true;
+    do {
+        const url = buildCalendarListURL({
+            syncToken: isFirstPage ? params.syncToken : undefined,
+            pageToken
+        });
+        const data = await fetchJSON(url, params.credential, params.fetchFn, params.signal);
+        yield {
+            items: data.items ?? [],
+            nextSyncToken: data.nextSyncToken,
+            isFirstPage
+        };
+        pageToken = data.nextPageToken;
+        isFirstPage = false;
+    }while (pageToken != null)
+}
+async function* fetchEventsForCalendar(params) {
+    let pageToken;
+    let isFirstPage = true;
+    do {
+        const url = buildEventsListURL({
+            calendarID: params.calendarID,
+            syncToken: isFirstPage ? params.syncToken : undefined,
+            pageToken,
+            timeMin: params.timeMin
+        });
+        const data = await fetchJSON(url, params.credential, params.fetchFn, params.signal);
+        yield {
+            items: data.items ?? [],
+            nextSyncToken: data.nextSyncToken
+        };
+        pageToken = data.nextPageToken;
+        isFirstPage = false;
+    }while (pageToken != null)
+}
+export function createGoogleCalendarProvider(config) {
+    const fetchFn = config.fetch ?? globalThis.fetch;
+    const excludeSet = new Set(config.excludeCalendars ?? []);
+    async function* fetchAllEntities(params) {
+        const timeMin = computeTimeMin(params.boundary);
+        // Phase 1: fetch all calendars (collect all pages first, then yield single batch)
+        const allCalendars = [];
+        let calendarListSyncToken;
+        for await (const page of fetchAllCalendars({
+            credential: config.credential,
+            fetchFn,
+            signal: params.signal
+        })){
+            for (const cal of page.items){
+                if (!excludeSet.has(cal.id)) {
+                    allCalendars.push(cal);
+                }
+            }
+            if (page.nextSyncToken != null) {
+                calendarListSyncToken = page.nextSyncToken;
+            }
+        }
+        // Yield calendar batch (no checkpoint yet — will be on the last event batch)
+        yield {
+            modelID: CALENDAR_MODEL_ID,
+            entities: allCalendars.map(mapCalendarToEntity),
+            hasMore: true
+        };
+        // Phase 2: fetch events per calendar
+        const calendarTokens = {};
+        let eventBatchYielded = false;
+        for(let i = 0; i < allCalendars.length; i++){
+            const calendar = allCalendars[i];
+            const isLastCalendar = i === allCalendars.length - 1;
+            let eventsSyncToken;
+            for await (const page of fetchEventsForCalendar({
+                calendarID: calendar.id,
+                credential: config.credential,
+                fetchFn,
+                timeMin,
+                signal: params.signal
+            })){
+                if (page.nextSyncToken != null) {
+                    eventsSyncToken = page.nextSyncToken;
+                }
+                const isLastPage = page.nextSyncToken != null // last page has nextSyncToken
+                ;
+                const checkpoint = isLastCalendar && isLastPage ? {
+                    calendarListSyncToken,
+                    calendars: {
+                        ...calendarTokens,
+                        [calendar.id]: {
+                            eventsSyncToken: page.nextSyncToken
+                        }
+                    }
+                } : 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');
+                yield {
+                    modelID: CALENDAR_EVENT_MODEL_ID,
+                    entities: activeItems.map((event)=>mapEventToEntity(event, calendar.id)),
+                    deleted: cancelledItems.map((e)=>({
+                            sourceService: 'google-calendar',
+                            sourceID: e.id
+                        })),
+                    hasMore: !(isLastCalendar && isLastPage),
+                    checkpoint
+                };
+                eventBatchYielded = true;
+            }
+            calendarTokens[calendar.id] = {
+                eventsSyncToken
+            };
+        }
+        // If no event batches were yielded (zero calendars), emit a final empty batch
+        // with hasMore: false and the checkpoint so the sync can complete.
+        if (!eventBatchYielded) {
+            yield {
+                modelID: CALENDAR_EVENT_MODEL_ID,
+                entities: [],
+                hasMore: false,
+                checkpoint: {
+                    calendarListSyncToken,
+                    calendars: calendarTokens
+                }
+            };
+        }
+    }
+    return {
+        supportedStrategies: [
+            'on-demand'
+        ],
+        fetchAll: fetchAllEntities,
+        async *fetchChanges (params) {
+            const checkpoint = params.checkpoint;
+            if (checkpoint == null) {
+                yield* fetchAllEntities(params);
+                return;
+            }
+            const timeMin = computeTimeMin(params.boundary);
+            // Phase 1: fetch calendar list changes using stored syncToken
+            const activeCalendars = [];
+            const deletedCalendarIDs = [];
+            let newCalendarListSyncToken;
+            for await (const page of fetchAllCalendars({
+                credential: config.credential,
+                fetchFn,
+                syncToken: checkpoint.calendarListSyncToken,
+                signal: params.signal
+            })){
+                for (const cal of page.items){
+                    if (cal.deleted === true) {
+                        deletedCalendarIDs.push(cal.id);
+                    } else if (!excludeSet.has(cal.id)) {
+                        activeCalendars.push(cal);
+                    }
+                }
+                if (page.nextSyncToken != null) {
+                    newCalendarListSyncToken = page.nextSyncToken;
+                }
+            }
+            // Yield calendar batch (active + deletions)
+            yield {
+                modelID: CALENDAR_MODEL_ID,
+                entities: activeCalendars.map(mapCalendarToEntity),
+                deleted: deletedCalendarIDs.map((id)=>({
+                        sourceService: 'google-calendar',
+                        sourceID: id
+                    })),
+                hasMore: true
+            };
+            // Phase 2: determine the set of calendars to sync events for
+            // Start from the previous calendar set, remove deleted, add newly discovered active ones
+            const prevCalendarTokens = {
+                ...checkpoint.calendars
+            };
+            for (const deletedID of deletedCalendarIDs){
+                delete prevCalendarTokens[deletedID];
+            }
+            // Collect new calendars that weren't in the previous checkpoint
+            const newlyDiscoveredCalendars = activeCalendars.filter((cal)=>!(cal.id in checkpoint.calendars));
+            // All calendars to sync: known (from prev checkpoint, minus deleted) + newly discovered
+            const knownCalendarIDs = Object.keys(prevCalendarTokens);
+            // Combine: known calendar IDs (we don't have resource objects for them, only IDs)
+            // plus newly discovered calendar resources
+            const allCalendarIDsToSync = [
+                ...knownCalendarIDs.map((id)=>({
+                        id,
+                        isNew: false
+                    })),
+                ...newlyDiscoveredCalendars.map((cal)=>({
+                        id: cal.id,
+                        isNew: true
+                    }))
+            ];
+            const updatedCalendarTokens = {};
+            for(let i = 0; i < allCalendarIDsToSync.length; i++){
+                const { id: calendarID, isNew } = allCalendarIDsToSync[i];
+                const isLastCalendar = i === allCalendarIDsToSync.length - 1;
+                // Use stored syncToken for known calendars; use timeMin for new ones
+                const storedToken = isNew ? undefined : prevCalendarTokens[calendarID]?.eventsSyncToken;
+                let eventsSyncToken;
+                for await (const page of fetchEventsForCalendar({
+                    calendarID,
+                    credential: config.credential,
+                    fetchFn,
+                    syncToken: storedToken,
+                    timeMin: isNew ? timeMin : undefined,
+                    signal: params.signal
+                })){
+                    if (page.nextSyncToken != null) {
+                        eventsSyncToken = page.nextSyncToken;
+                    }
+                    const isLastPage = page.nextSyncToken != null;
+                    const newCheckpoint = isLastCalendar && isLastPage ? {
+                        calendarListSyncToken: newCalendarListSyncToken,
+                        calendars: {
+                            ...updatedCalendarTokens,
+                            [calendarID]: {
+                                eventsSyncToken: page.nextSyncToken
+                            }
+                        }
+                    } : 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');
+                    yield {
+                        modelID: CALENDAR_EVENT_MODEL_ID,
+                        entities: activeItems.map((event)=>mapEventToEntity(event, calendarID)),
+                        deleted: cancelledItems.map((e)=>({
+                                sourceService: 'google-calendar',
+                                sourceID: e.id
+                            })),
+                        hasMore: !(isLastCalendar && isLastPage),
+                        checkpoint: newCheckpoint
+                    };
+                }
+                updatedCalendarTokens[calendarID] = {
+                    eventsSyncToken
+                };
+            }
+            // If no event batches were yielded (zero calendars to sync), emit a final empty
+            // batch with hasMore: false and the composite checkpoint so the sync can complete.
+            if (allCalendarIDsToSync.length === 0) {
+                yield {
+                    modelID: CALENDAR_EVENT_MODEL_ID,
+                    entities: [],
+                    hasMore: false,
+                    checkpoint: {
+                        calendarListSyncToken: newCalendarListSyncToken,
+                        calendars: updatedCalendarTokens
+                    }
+                };
+            }
+        }
+    };
+}

package/package.json

@@ -1,34 +1,34 @@
 {
   "name": "@kubun/connector-google-calendar",
-  "version": "0.10.0",
-  "license": "see LICENSE.md",
+  "version": "0.12.0",
   "keywords": [],
+  "license": "see LICENSE.md",
+  "sideEffects": false,
   "type": "module",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
   "exports": {
     ".": "./lib/index.js"
   },
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "files": [
     "lib/*",
     "LICENSE.md"
   ],
-  "sideEffects": false,
   "dependencies": {
-    "@kubun/connector": "^0.10.0",
-    "@kubun/models": "^0.10.0",
-    "@kubun/scalars": "^0.10.0",
-    "@kubun/protocol": "^0.10.0",
-    "@kubun/provider-google": "^0.10.0"
+    "@kubun/connector": "^0.12.0",
+    "@kubun/provider-google": "^0.12.0",
+    "@kubun/models": "^0.12.0",
+    "@kubun/protocol": "^0.12.0",
+    "@kubun/scalars": "^0.12.0"
   },
   "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 ../../swc.json --strip-leading-paths",
+    "build:js": "swc src -d ./lib --config-file ../../node_modules/@kigu/dev/swc.json --strip-leading-paths",
     "build:types": "tsc --emitDeclarationOnly --skipLibCheck",
     "build:types:ci": "tsc --emitDeclarationOnly --declarationMap false",
-    "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
+    "test": "pnpm run test:types && pnpm run test:unit",
     "test:types": "tsc --noEmit -p tsconfig.test.json",
-    "test:unit": "vitest run",
-    "test": "pnpm run test:types && pnpm run test:unit"
+    "test:unit": "vitest run"
   }
 }