@particle-academy/google-calendar-js 0.0.0 → 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,398 @@
+import { ServiceDescriptor, PreparedRequest, ConnectorMode, ConnectorFaker, RequestedMode, Transport, ConnectorResult, TriggerDescriptor, LeaseDeclaration, SharedTokenScheme, InboundDelivery, WebhookVerification } from '@particle-academy/fancy-connector-core';
+
+/**
+ * GENERATED FILE — do not edit.
+ *
+ * Emitted from provider/manifest.json by weaver's generator.
+ * A hand-edit here is destroyed by the next protocol sync, which is worse than
+ * being rejected, because it works until it silently does not. Fix
+ * provider/manifest.json (or weaver's template/) and regenerate:
+ *
+ *     npm run provider -- google_calendar
+ */
+/**
+ * Google Calendar, as one service descriptor shared by every Google Calendar
+ * operation.
+ *
+ * @particle-academy/fancy-connector-core carries what is true of ALL
+ * connectors. This carries what is true of Google Calendar: its base URL, its
+ * auth scheme, its idempotency header, and its faker.
+ *
+ * ## The sandbox trap, written down where it is used
+ *
+ * Google has no sandbox for Calendar. A test calendar is a real one in a real
+ * account, so every watch and every read is real -- point this at a scratch
+ * calendar, not a production one. The faker is the only way to develop against
+ * it without touching an account.
+ */
+
+/**
+ * The connector API version this package was GENERATED against.
+ *
+ * A literal, never imported. An imported constant lets an upgrade rewrite the
+ * very claim it exists to detect, after which the copy agrees with itself
+ * forever.
+ */
+declare const CONNECTOR_API_VERSION = 1;
+declare const GOOGLE_CALENDAR_BASE_URLS: {
+    readonly live: "https://www.googleapis.com";
+};
+/** Credential keys a remote call cannot proceed without. */
+declare const GOOGLE_CALENDAR_REQUIRES: readonly ["accessToken", "refreshToken", "clientId", "clientSecret"];
+/**
+ * Apply Google Calendar's auth scheme to an outgoing request.
+ *
+ *
+ *
+ * The mode is passed in because for some providers auth and estate are the
+ * same decision expressed in the URL; here it is unused, and saying so is
+ * cheaper than wondering later whether it was forgotten.
+ */
+declare function googleCalendarAuthorize(credentials: Record<string, string | undefined>, request: PreparedRequest, _mode: ConnectorMode): void;
+/** The Google Calendar service, for the TypeScript runtime. */
+declare const GOOGLE_CALENDAR: ServiceDescriptor;
+
+/**
+ * GENERATED FILE — do not edit.
+ *
+ * Emitted from provider/fixtures/ by weaver's generator.
+ * A hand-edit here is destroyed by the next protocol sync, which is worse than
+ * being rejected, because it works until it silently does not. Fix
+ * provider/fixtures/ (or weaver's template/) and regenerate:
+ *
+ *     npm run provider -- google_calendar
+ */
+/**
+ * The Google Calendar faker.
+ *
+ * Shapes, not behaviour: the goal is that a downstream node sees the field
+ * NAMES Google Calendar actually publishes, so an author can wire {{
+ * $json.data.id }} against a fake and have it keep working against the real
+ * thing.
+ *
+ * Deterministic — same inputs, same output. A faker returning a fresh uuid
+ * every call cannot be asserted on, so its fixtures degrade to "it did not
+ * throw", which is the assertion that catches nothing.
+ */
+
+declare const googleCalendarFaker: ConnectorFaker;
+
+/**
+ * GENERATED FILE — do not edit.
+ *
+ * Emitted from provider/actions/channel-stop.json by weaver's generator.
+ * A hand-edit here is destroyed by the next protocol sync, which is worse than
+ * being rejected, because it works until it silently does not. Fix
+ * provider/actions/channel-stop.json (or weaver's template/) and regenerate:
+ *
+ *     npm run provider -- google_calendar
+ */
+/**
+ * Close a push-notification channel. The host's subscription machinery calls
+ * this before re-creating a channel and when a trigger is removed.
+ *
+ * POST /calendar/v3/channels/stop —
+ * https://developers.google.com/workspace/calendar/api/v3/reference/channels/stop
+ *
+ * Notice what is NOT here: no key, no base URL, no mode check, no retry loop,
+ * no fake/real branch. This describes the request; callConnector resolves the
+ * connection, picks the estate, and either calls Google Calendar or calls the
+ * faker.
+ */
+
+declare const CHANNEL_STOP_OPERATION = "channel_stop";
+type ChannelStopOptions = {
+    /** The node's resolved config. Keys: channelId, resourceId. */
+    config: Record<string, unknown>;
+    credentials?: Record<string, string | undefined>;
+    mode?: RequestedMode;
+    connectionId?: string | null;
+    input?: unknown;
+    attempts?: number;
+    /** Override the transport. The only way to exercise this without a network. */
+    transport?: Transport;
+};
+declare function googleCalendarChannelStop(options: ChannelStopOptions): Promise<ConnectorResult>;
+
+/**
+ * GENERATED FILE — do not edit.
+ *
+ * Emitted from provider/actions/channel-watch.json by weaver's generator.
+ * A hand-edit here is destroyed by the next protocol sync, which is worse than
+ * being rejected, because it works until it silently does not. Fix
+ * provider/actions/channel-watch.json (or weaver's template/) and regenerate:
+ *
+ *     npm run provider -- google_calendar
+ */
+/**
+ * Open a push-notification channel on a calendar's events. The host's
+ * subscription machinery calls this; it is not a node most workflows need.
+ *
+ * POST /calendar/v3/calendars/{calendarId}/events/watch —
+ * https://developers.google.com/workspace/calendar/api/v3/reference/events/watch
+ *
+ * Notice what is NOT here: no key, no base URL, no mode check, no retry loop,
+ * no fake/real branch. This describes the request; callConnector resolves the
+ * connection, picks the estate, and either calls Google Calendar or calls the
+ * faker.
+ *
+ * sideEffects: unsafe-to-replay.
+ */
+
+declare const CHANNEL_WATCH_OPERATION = "channel_watch";
+type ChannelWatchOptions = {
+    /** The node's resolved config. Keys: calendarId, channelId, address, token, ttlSeconds. */
+    config: Record<string, unknown>;
+    credentials?: Record<string, string | undefined>;
+    mode?: RequestedMode;
+    connectionId?: string | null;
+    input?: unknown;
+    attempts?: number;
+    /** Override the transport. The only way to exercise this without a network. */
+    transport?: Transport;
+};
+declare function googleCalendarChannelWatch(options: ChannelWatchOptions): Promise<ConnectorResult>;
+
+/**
+ * GENERATED FILE — do not edit.
+ *
+ * Emitted from provider/actions/event-create.json by weaver's generator.
+ * A hand-edit here is destroyed by the next protocol sync, which is worse than
+ * being rejected, because it works until it silently does not. Fix
+ * provider/actions/event-create.json (or weaver's template/) and regenerate:
+ *
+ *     npm run provider -- google_calendar
+ */
+/**
+ * Create a timed event on a Google Calendar.
+ *
+ * POST /calendar/v3/calendars/{calendarId}/events —
+ * https://developers.google.com/workspace/calendar/api/v3/reference/events/insert
+ *
+ * Notice what is NOT here: no key, no base URL, no mode check, no retry loop,
+ * no fake/real branch. This describes the request; callConnector resolves the
+ * connection, picks the estate, and either calls Google Calendar or calls the
+ * faker.
+ *
+ * sideEffects: unsafe-to-replay.
+ */
+
+declare const EVENT_CREATE_OPERATION = "event_create";
+type EventCreateOptions = {
+    /** The node's resolved config. Keys: calendarId, summary, description, location, startDateTime, startTimeZone, endDateTime, endTimeZone, status, visibility, transparency, colorId. */
+    config: Record<string, unknown>;
+    credentials?: Record<string, string | undefined>;
+    mode?: RequestedMode;
+    connectionId?: string | null;
+    input?: unknown;
+    attempts?: number;
+    /** Override the transport. The only way to exercise this without a network. */
+    transport?: Transport;
+};
+declare function googleCalendarEventCreate(options: EventCreateOptions): Promise<ConnectorResult>;
+
+/**
+ * GENERATED FILE — do not edit.
+ *
+ * Emitted from provider/actions/event-delete.json by weaver's generator.
+ * A hand-edit here is destroyed by the next protocol sync, which is worse than
+ * being rejected, because it works until it silently does not. Fix
+ * provider/actions/event-delete.json (or weaver's template/) and regenerate:
+ *
+ *     npm run provider -- google_calendar
+ */
+/**
+ * Remove an event from a Google Calendar.
+ *
+ * DELETE /calendar/v3/calendars/{calendarId}/events/{eventId} —
+ * https://developers.google.com/workspace/calendar/api/v3/reference/events/delete
+ *
+ * Notice what is NOT here: no key, no base URL, no mode check, no retry loop,
+ * no fake/real branch. This describes the request; callConnector resolves the
+ * connection, picks the estate, and either calls Google Calendar or calls the
+ * faker.
+ */
+
+declare const EVENT_DELETE_OPERATION = "event_delete";
+type EventDeleteOptions = {
+    /** The node's resolved config. Keys: calendarId, eventId. */
+    config: Record<string, unknown>;
+    credentials?: Record<string, string | undefined>;
+    mode?: RequestedMode;
+    connectionId?: string | null;
+    input?: unknown;
+    attempts?: number;
+    /** Override the transport. The only way to exercise this without a network. */
+    transport?: Transport;
+};
+declare function googleCalendarEventDelete(options: EventDeleteOptions): Promise<ConnectorResult>;
+
+/**
+ * GENERATED FILE — do not edit.
+ *
+ * Emitted from provider/actions/event-get.json by weaver's generator.
+ * A hand-edit here is destroyed by the next protocol sync, which is worse than
+ * being rejected, because it works until it silently does not. Fix
+ * provider/actions/event-get.json (or weaver's template/) and regenerate:
+ *
+ *     npm run provider -- google_calendar
+ */
+/**
+ * Read one event from a Google Calendar.
+ *
+ * GET /calendar/v3/calendars/{calendarId}/events/{eventId} —
+ * https://developers.google.com/workspace/calendar/api/v3/reference/events/get
+ *
+ * Notice what is NOT here: no key, no base URL, no mode check, no retry loop,
+ * no fake/real branch. This describes the request; callConnector resolves the
+ * connection, picks the estate, and either calls Google Calendar or calls the
+ * faker.
+ */
+
+declare const EVENT_GET_OPERATION = "event_get";
+type EventGetOptions = {
+    /** The node's resolved config. Keys: calendarId, eventId. */
+    config: Record<string, unknown>;
+    credentials?: Record<string, string | undefined>;
+    mode?: RequestedMode;
+    connectionId?: string | null;
+    input?: unknown;
+    attempts?: number;
+    /** Override the transport. The only way to exercise this without a network. */
+    transport?: Transport;
+};
+declare function googleCalendarEventGet(options: EventGetOptions): Promise<ConnectorResult>;
+
+/**
+ * GENERATED FILE — do not edit.
+ *
+ * Emitted from provider/actions/event-list.json by weaver's generator.
+ * A hand-edit here is destroyed by the next protocol sync, which is worse than
+ * being rejected, because it works until it silently does not. Fix
+ * provider/actions/event-list.json (or weaver's template/) and regenerate:
+ *
+ *     npm run provider -- google_calendar
+ */
+/**
+ * List events from a Google Calendar, in full or incrementally with a sync
+ * token.
+ *
+ * GET /calendar/v3/calendars/{calendarId}/events —
+ * https://developers.google.com/workspace/calendar/api/v3/reference/events/list
+ *
+ * Notice what is NOT here: no key, no base URL, no mode check, no retry loop,
+ * no fake/real branch. This describes the request; callConnector resolves the
+ * connection, picks the estate, and either calls Google Calendar or calls the
+ * faker.
+ */
+
+declare const EVENT_LIST_OPERATION = "event_list";
+type EventListOptions = {
+    /** The node's resolved config. Keys: calendarId, syncToken, timeMin, timeMax, maxResults, pageToken, singleEvents. */
+    config: Record<string, unknown>;
+    credentials?: Record<string, string | undefined>;
+    mode?: RequestedMode;
+    connectionId?: string | null;
+    input?: unknown;
+    attempts?: number;
+    /** Override the transport. The only way to exercise this without a network. */
+    transport?: Transport;
+};
+declare function googleCalendarEventList(options: EventListOptions): Promise<ConnectorResult>;
+
+/**
+ * GENERATED FILE — do not edit.
+ *
+ * Emitted from provider/actions/event-update.json by weaver's generator.
+ * A hand-edit here is destroyed by the next protocol sync, which is worse than
+ * being rejected, because it works until it silently does not. Fix
+ * provider/actions/event-update.json (or weaver's template/) and regenerate:
+ *
+ *     npm run provider -- google_calendar
+ */
+/**
+ * Change one or more fields of an existing event. Only the fields provided are
+ * touched.
+ *
+ * PATCH /calendar/v3/calendars/{calendarId}/events/{eventId} —
+ * https://developers.google.com/workspace/calendar/api/v3/reference/events/patch
+ *
+ * Notice what is NOT here: no key, no base URL, no mode check, no retry loop,
+ * no fake/real branch. This describes the request; callConnector resolves the
+ * connection, picks the estate, and either calls Google Calendar or calls the
+ * faker.
+ */
+
+declare const EVENT_UPDATE_OPERATION = "event_update";
+type EventUpdateOptions = {
+    /** The node's resolved config. Keys: calendarId, eventId, summary, description, location, startDateTime, startTimeZone, endDateTime, endTimeZone, status, visibility, transparency, colorId. */
+    config: Record<string, unknown>;
+    credentials?: Record<string, string | undefined>;
+    mode?: RequestedMode;
+    connectionId?: string | null;
+    input?: unknown;
+    attempts?: number;
+    /** Override the transport. The only way to exercise this without a network. */
+    transport?: Transport;
+};
+declare function googleCalendarEventUpdate(options: EventUpdateOptions): Promise<ConnectorResult>;
+
+/**
+ * GENERATED FILE — do not edit.
+ *
+ * Emitted from provider/triggers/events-changed.json by weaver's generator.
+ * A hand-edit here is destroyed by the next protocol sync, which is worse than
+ * being rejected, because it works until it silently does not. Fix
+ * provider/triggers/events-changed.json (or weaver's template/) and regenerate:
+ *
+ *     npm run provider -- google_calendar
+ */
+/**
+ * Google Calendar's subscription trigger — the delivery contract.
+ *
+ * Kept beside the service descriptor rather than inside a node, because the
+ * way a delivery is verified is a fact about GOOGLE CALENDAR. Two Google
+ * Calendar triggers must not be able to disagree about how a delivery is
+ * verified.
+ *
+ * A SUBSCRIPTION: Google Calendar stops delivering unless somebody renews it,
+ * forever, and if nobody does the workflow stops firing with no error
+ * anywhere. The lease below says where the expiry is read from and how early
+ * to renew; the host runs ONE renewal scheduler for every expiring trigger.
+ */
+
+/** Where Google Calendar echoes the token it was given when the subscription was created. */
+declare const GOOGLE_CALENDAR_EVENTS_CHANGED_TOKEN_SCHEME: SharedTokenScheme;
+/**
+ * The lease this subscription carries: where the provider's expiry sits in the
+ * `channel_watch` response (`expiration`, epoch-ms), how early the host
+ * renews, and what it calls when the lease is due — the create again, because
+ * Google Calendar cannot renew. The host builds the value with the core's
+ * `leaseFromResponse` and runs one scheduler for every expiring trigger.
+ */
+declare const GOOGLE_CALENDAR_EVENTS_CHANGED_LEASE: LeaseDeclaration;
+/**
+ * Which of this package's actions create, renew and stop the subscription.
+ * `renew` is null where the provider cannot renew and the host calls create
+ * again — after stopping the old one, and after re-listing, because
+ * notifications during the gap are gone.
+ */
+declare const GOOGLE_CALENDAR_EVENTS_CHANGED_SUBSCRIPTION: {
+    readonly create: "channel_watch";
+    readonly renew: null;
+    readonly stop: "channel_stop";
+};
+declare const GOOGLE_CALENDAR_EVENTS_CHANGED: TriggerDescriptor;
+/**
+ * Verify one inbound Google Calendar delivery.
+ *
+ * The host calls this BEFORE starting a run, with the body exactly as
+ * received. Re-serialised JSON changes key order and whitespace, and produces
+ * a mismatch that looks precisely like a wrong secret — hours of debugging the
+ * wrong thing.
+ *
+ * The secret is the connection's `channelToken`.
+ */
+declare function verifyGoogleCalendarDelivery(delivery: InboundDelivery, channelToken: string | undefined, now?: number): Promise<WebhookVerification>;
+
+export { CHANNEL_STOP_OPERATION, CHANNEL_WATCH_OPERATION, CONNECTOR_API_VERSION, type ChannelStopOptions, type ChannelWatchOptions, EVENT_CREATE_OPERATION, EVENT_DELETE_OPERATION, EVENT_GET_OPERATION, EVENT_LIST_OPERATION, EVENT_UPDATE_OPERATION, type EventCreateOptions, type EventDeleteOptions, type EventGetOptions, type EventListOptions, type EventUpdateOptions, GOOGLE_CALENDAR, GOOGLE_CALENDAR_BASE_URLS, GOOGLE_CALENDAR_EVENTS_CHANGED, GOOGLE_CALENDAR_EVENTS_CHANGED_LEASE, GOOGLE_CALENDAR_EVENTS_CHANGED_SUBSCRIPTION, GOOGLE_CALENDAR_EVENTS_CHANGED_TOKEN_SCHEME, GOOGLE_CALENDAR_REQUIRES, googleCalendarAuthorize, googleCalendarChannelStop, googleCalendarChannelWatch, googleCalendarEventCreate, googleCalendarEventDelete, googleCalendarEventGet, googleCalendarEventList, googleCalendarEventUpdate, googleCalendarFaker, verifyGoogleCalendarDelivery };

package/dist/index.js

@@ -0,0 +1,3 @@
+export { CHANNEL_STOP_OPERATION, CHANNEL_WATCH_OPERATION, CONNECTOR_API_VERSION, EVENT_CREATE_OPERATION, EVENT_DELETE_OPERATION, EVENT_GET_OPERATION, EVENT_LIST_OPERATION, EVENT_UPDATE_OPERATION, GOOGLE_CALENDAR, GOOGLE_CALENDAR_BASE_URLS, GOOGLE_CALENDAR_EVENTS_CHANGED, GOOGLE_CALENDAR_EVENTS_CHANGED_LEASE, GOOGLE_CALENDAR_EVENTS_CHANGED_SUBSCRIPTION, GOOGLE_CALENDAR_EVENTS_CHANGED_TOKEN_SCHEME, GOOGLE_CALENDAR_REQUIRES, googleCalendarAuthorize, googleCalendarChannelStop, googleCalendarChannelWatch, googleCalendarEventCreate, googleCalendarEventDelete, googleCalendarEventGet, googleCalendarEventList, googleCalendarEventUpdate, googleCalendarFaker, verifyGoogleCalendarDelivery } from './chunk-7CMSUBWQ.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/package.json

@@ -1,18 +1,90 @@
 {
   "name": "@particle-academy/google-calendar-js",
-  "version": "0.0.0",
-  "description": "A placeholder that claims the name @particle-academy/google-calendar-js; the real release follows through Fancy-Friends/google-calendar's publish.yml with provenance. Do not install this version.",
-  "license": "MIT",
+  "version": "0.2.0",
+  "description": "Google Calendar for Node — the service descriptor, its faker, its webhook verification, and one function per operation. Plain HTTP on @particle-academy/fancy-connector-core; no vendor SDK.",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Fancy-Friends/google-calendar.git",
     "directory": "packages/js"
   },
   "homepage": "https://github.com/Fancy-Friends/google-calendar#readme",
+  "bugs": "https://github.com/Fancy-Friends/google-calendar/issues",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./flow": {
+      "import": {
+        "types": "./dist/flow.d.ts",
+        "default": "./dist/flow.js"
+      },
+      "require": {
+        "types": "./dist/flow.d.cts",
+        "default": "./dist/flow.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "art",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "lint": "tsc --noEmit",
+    "test": "node --import tsx --test tests/*.test.ts",
+    "prepublishOnly": "tsup"
+  },
+  "dependencies": {
+    "@particle-academy/fancy-connector-core": ">=0.8.0 <2.0"
+  },
+  "peerDependencies": {
+    "@particle-academy/fancy-flow": ">=0.47.1 <2.0",
+    "@particle-academy/google-calendar-ui": ">=0.2.0 <0.3.0"
+  },
+  "peerDependenciesMeta": {
+    "@particle-academy/fancy-flow": {
+      "optional": true
+    },
+    "@particle-academy/google-calendar-ui": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@particle-academy/fancy-flow": ">=0.47.1 <2.0",
+    "@types/node": "^26.2.0",
+    "tsup": "^8.5.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.8.0"
+  },
   "publishConfig": {
     "access": "public"
   },
-  "files": [
-    "README.md"
-  ]
+  "keywords": [
+    "google_calendar",
+    "calendar",
+    "connector",
+    "api",
+    "fancy-ui",
+    "particle-academy"
+  ],
+  "license": "MIT",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=22"
+  }
 }