@oomol-lab/open-connector 1.6.5 → 1.8.0

package/src/providers/notion_mcp/mcp-response.js

@@ -0,0 +1,314 @@
+import { compactObject, looseArray, optionalRawString, optionalRecord, optionalString, pickOptionalString, recordOrEmpty, } from "../../core/cast.js";
+// Tag and attribute patterns exclude `<` and use a lookbehind so each scan is linear in the text length: page
+// content and comments are user-written, and a quadratic pattern would block the event loop on a crafted answer.
+const pageTag = /<page\b([^<>]*)>/i;
+const contentOpening = /<content\b[^<>]*>/i;
+const tagAttribute = /(?<![\w:-])([\w:-]+)\s*=\s*"([^"]*)"/g;
+const anyTag = /<[^<>]+>/g;
+const namedEntities = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
+/** Notion's tools answer JSON in a text block on most calls and prose or XML fragments on the rest. */
+export function decodeNotionToolText(text) {
+    const trimmed = text.trim();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            // Not JSON after all: the text is the value.
+        }
+    }
+    return text;
+}
+/**
+ * The connected user as notion-get-users answers `user_id: "self"`: the first listed user of
+ * `{results: [{type, id, name, email}], has_more}` that carries an ID or an email, or the answer itself when it is a
+ * single user.
+ */
+export function parseNotionSelf(value) {
+    const users = findList(value, "results", "users").flatMap((item) => {
+        const user = readUser(item);
+        return user ? [user] : [];
+    });
+    const candidates = users.length > 0 ? users : [readUser(value)];
+    return candidates.find((user) => user?.id !== undefined || user?.email !== undefined);
+}
+/**
+ * Search results plus the server's notices, such as a filter dropped on the connected plan, and the search `type`
+ * the server reports: `workspace_search`, or `ai_search` when it routed a keyword query to Notion AI search.
+ */
+export function parseNotionSearch(value) {
+    const record = optionalRecord(value);
+    const results = findList(value, "results", "pages", "items").flatMap((item) => {
+        const result = optionalRecord(item);
+        if (!result)
+            return [];
+        const typed = compactObject({
+            id: pickOptionalString(result, "id"),
+            title: readTitle(result),
+            url: pickOptionalString(result, "url"),
+            type: pickOptionalString(result, "type"),
+            timestamp: pickOptionalString(result, "timestamp", "last_edited_time"),
+            path: pickOptionalString(result, "path"),
+        });
+        return [typed];
+    });
+    return { type: record && pickOptionalString(record, "type"), results, notices: readNotices(record?.notices) };
+}
+/**
+ * The page envelope notion-fetch answers: a preamble line, then
+ * `<page url="..."><properties>...</properties><content>MARKDOWN</content></page>`, either bare in the text block or
+ * under `text` of a `{title, url, page_last_edited_at, text}` object. A page the server cut says so with a
+ * `truncated` flag on the object or on the tag.
+ */
+export function parseNotionPage(value) {
+    const record = optionalRecord(value);
+    const text = record ? pickOptionalString(record, "text", "content", "markdown", "body") : optionalString(value);
+    const tag = text === undefined ? null : pageTag.exec(text);
+    const attributes = tag ? readAttributes(tag[1]) : {};
+    const properties = text === undefined ? undefined : nextXmlBlock(text, "properties", 0);
+    const content = text === undefined ? undefined : nextXmlBlock(text, "content", 0);
+    let body;
+    if (content) {
+        body = content.body;
+    }
+    else if (text !== undefined) {
+        // No closed content block: an unclosed one takes the rest; a bare answer is the whole text.
+        const opening = contentOpening.exec(text);
+        body = opening ? text.slice(opening.index + opening[0].length) : text;
+    }
+    return {
+        ...compactObject({
+            title: (record && pickOptionalString(record, "title")) ?? optionalString(attributes.title),
+            url: (record && pickOptionalString(record, "url")) ?? optionalString(attributes.url),
+            page_last_edited_at: (record && pickOptionalString(record, "page_last_edited_at", "last_edited_time")) ??
+                optionalString(attributes.page_last_edited_at ?? attributes.last_edited_time),
+            properties: properties ? unescapeEntities(properties.body).trim() : undefined,
+            content: body === undefined ? undefined : unescapeEntities(body).trim(),
+        }),
+        truncated: record?.truncated === true ||
+            isTrue(attributes.truncated) ||
+            (content !== undefined && isTrue(readAttributes(content.attributes).truncated)),
+    };
+}
+/**
+ * Comments as notion-get-comments answers them, in both recorded shapes: the structured
+ * `{discussions: [{id, comments: [{id, plain_text, created_time, created_by}]}]}` (or a flat `{comments: [...]}`),
+ * or the XML twin `<discussion id><comment id author author_id created_time>text</comment></discussion>`.
+ */
+export function parseNotionComments(value) {
+    const record = optionalRecord(value);
+    if (!record) {
+        const text = optionalString(value);
+        return text === undefined ? [] : readXmlComments(text);
+    }
+    const comments = findList(record, "comments", "results", "items").flatMap((item) => readComment(item, undefined));
+    for (const discussion of findList(record, "discussions")) {
+        const thread = optionalRecord(discussion);
+        if (!thread)
+            continue;
+        const discussionId = pickOptionalString(thread, "id", "discussion_id");
+        comments.push(...findList(thread, "comments", "results").flatMap((item) => readComment(item, discussionId)));
+    }
+    if (comments.length > 0)
+        return comments;
+    const text = pickOptionalString(record, "text");
+    return text === undefined ? [] : readXmlComments(text);
+}
+/**
+ * The plan report notion-get-tool-access answers: `{current_tool_access: {<tool>: {status, restricted_parameters?,
+ * upgrade_url?, full_version_url?, landing_page_url?, landing_page_action?}}}`, keyed by each tool's base name
+ * (`search`, `ai_search`), where `restricted_parameters` maps a parameter path such as `filters.title_only` to the
+ * reason it is unavailable. The reason is kept as text and never interpreted.
+ */
+export function parseNotionToolAccess(value) {
+    const access = recordOrEmpty(optionalRecord(value)?.current_tool_access);
+    return Object.entries(access).flatMap(([tool, item]) => {
+        const entry = optionalRecord(item);
+        if (!entry)
+            return [];
+        const restrictions = Object.entries(recordOrEmpty(entry.restricted_parameters)).map(([parameter, reason]) => ({
+            parameter,
+            reason: optionalRawString(reason) ?? JSON.stringify(reason),
+        }));
+        return [
+            {
+                tool,
+                status: pickOptionalString(entry, "status"),
+                restricted_parameters: restrictions,
+                upgrade_url: pickOptionalString(entry, "upgrade_url"),
+                full_version_url: pickOptionalString(entry, "full_version_url"),
+                landing_page_url: pickOptionalString(entry, "landing_page_url"),
+                landing_page_action: pickOptionalString(entry, "landing_page_action"),
+            },
+        ];
+    });
+}
+/** The first present list among keys of a decoded object, or the value itself when it is a list. */
+function findList(value, ...keys) {
+    if (Array.isArray(value))
+        return value;
+    const record = optionalRecord(value);
+    if (!record)
+        return [];
+    for (const key of keys) {
+        if (Array.isArray(record[key]))
+            return looseArray(record[key]);
+    }
+    return [];
+}
+function readUser(value) {
+    const record = optionalRecord(value);
+    if (!record)
+        return undefined;
+    const user = compactObject({
+        id: pickOptionalString(record, "id", "user_id"),
+        name: pickOptionalString(record, "name"),
+        email: pickOptionalString(record, "email"),
+        type: pickOptionalString(record, "type"),
+    });
+    return Object.keys(user).length > 0 ? user : undefined;
+}
+/** A result title as the server spells it: a plain string, or the API's rich-text array under properties. */
+function readTitle(record) {
+    const plain = pickOptionalString(record, "title", "name");
+    if (plain)
+        return plain;
+    const properties = optionalRecord(record.properties);
+    if (!properties)
+        return undefined;
+    for (const key of ["title", "Name", "name"]) {
+        const property = optionalRecord(properties[key]);
+        if (!property)
+            continue;
+        const text = looseArray(property.title)
+            .map((part) => optionalRawString(optionalRecord(part)?.plain_text) ?? "")
+            .join("");
+        if (text.trim())
+            return text.trim();
+    }
+    return undefined;
+}
+/** A notice is a sentence or an object naming a parameter; either way its text is kept, never interpreted. */
+function readNotices(value) {
+    const single = optionalString(value);
+    if (single)
+        return [single];
+    return looseArray(value).flatMap((item) => {
+        const text = optionalString(item);
+        if (text)
+            return [text];
+        const record = optionalRecord(item);
+        if (!record)
+            return [];
+        return [
+            pickOptionalString(record, "message", "parameter", "field", "name", "detail", "text") ?? JSON.stringify(record),
+        ];
+    });
+}
+function readComment(value, discussionId) {
+    const record = optionalRecord(value);
+    if (!record)
+        return [];
+    const author = optionalRecord(record.created_by);
+    const createdBy = author
+        ? (readUser(author) ?? {})
+        : compactObject({
+            id: pickOptionalString(record, "author_id", "user_id"),
+            name: pickOptionalString(record, "author", "author_name"),
+            email: pickOptionalString(record, "author_email"),
+        });
+    const comment = compactObject({
+        id: pickOptionalString(record, "id", "comment_id"),
+        discussion_id: pickOptionalString(record, "discussion_id") ?? discussionId,
+        plain_text: pickOptionalString(record, "plain_text", "text", "content", "body"),
+        created_time: pickOptionalString(record, "created_time", "created_at", "timestamp"),
+        created_by: Object.keys(createdBy).length > 0 ? createdBy : undefined,
+    });
+    return comment.id !== undefined || comment.plain_text !== undefined ? [comment] : [];
+}
+function readXmlComments(text) {
+    const comments = [];
+    let remainder = "";
+    let last = 0;
+    for (const block of xmlBlocks(text, "discussion")) {
+        remainder += text.slice(last, block.start);
+        last = block.end;
+        const attributes = readAttributes(block.attributes);
+        comments.push(...readXmlCommentTags(block.body, optionalString(attributes.id ?? attributes.discussion_id)));
+    }
+    remainder += text.slice(last);
+    comments.push(...readXmlCommentTags(remainder, undefined));
+    return comments;
+}
+function readXmlCommentTags(text, discussionId) {
+    return xmlBlocks(text, "comment").flatMap((block) => {
+        const attributes = readAttributes(block.attributes);
+        const createdBy = compactObject({
+            id: optionalString(attributes.author_id ?? attributes.user_id ?? attributes.created_by_id),
+            name: optionalString(attributes.author ?? attributes.author_name ?? attributes.created_by ?? attributes.user),
+            email: optionalString(attributes.author_email ?? attributes.email),
+        });
+        const comment = compactObject({
+            id: optionalString(attributes.id ?? attributes.comment_id),
+            discussion_id: optionalString(attributes.discussion_id) ?? discussionId,
+            plain_text: optionalString(unescapeEntities(block.body.replace(anyTag, " ")).replace(/[ \t]{2,}/g, " ")),
+            created_time: optionalString(attributes.created_time ?? attributes.created_at ?? attributes.timestamp ?? attributes.time ?? attributes.date),
+            created_by: Object.keys(createdBy).length > 0 ? createdBy : undefined,
+        });
+        return comment.plain_text !== undefined ? [comment] : [];
+    });
+}
+/** Every `<tag ...>body</tag>` element in order, each scan resuming after the previous element. */
+function xmlBlocks(text, tag) {
+    const blocks = [];
+    for (let block = nextXmlBlock(text, tag, 0); block; block = nextXmlBlock(text, tag, block.end)) {
+        blocks.push(block);
+    }
+    return blocks;
+}
+/**
+ * The first `<tag ...>body</tag>` element at or after `from`, ending at the first closing tag after its opening.
+ * When that opening has no closing tag after it, no later opening can have one either, so the scan stops instead of
+ * retrying every opening the way a lazy `[\s\S]*?` pattern does.
+ */
+function nextXmlBlock(text, tag, from) {
+    const opening = new RegExp(`<${tag}\\b([^<>]*)>`, "gi");
+    opening.lastIndex = from;
+    const open = opening.exec(text);
+    if (!open)
+        return undefined;
+    const closing = new RegExp(`</${tag}>`, "gi");
+    closing.lastIndex = opening.lastIndex;
+    const close = closing.exec(text);
+    if (!close)
+        return undefined;
+    return {
+        attributes: open[1],
+        body: text.slice(opening.lastIndex, close.index),
+        start: open.index,
+        end: closing.lastIndex,
+    };
+}
+/** The attributes of one tag's attribute text, names lower-cased and values entity-decoded. */
+function readAttributes(attributes) {
+    const found = {};
+    for (const match of attributes.matchAll(tagAttribute)) {
+        found[match[1].toLowerCase()] = unescapeEntities(match[2]);
+    }
+    return found;
+}
+function isTrue(value) {
+    return value?.trim().toLowerCase() === "true";
+}
+/** The XML entities Notion escapes inside its envelopes; the Markdown itself is left alone. */
+function unescapeEntities(text) {
+    return text.replace(/&(#x[0-9a-f]+|#\d+|amp|lt|gt|quot|apos);/gi, (entity, body) => {
+        if (body.startsWith("#")) {
+            const hex = body[1] === "x" || body[1] === "X";
+            const code = Number.parseInt(body.slice(hex ? 2 : 1), hex ? 16 : 10);
+            // A number past U+10FFFF names no character, and String.fromCodePoint throws on it; keep the entity as text.
+            return code <= 0x10ffff ? String.fromCodePoint(code) : entity;
+        }
+        return namedEntities[body.toLowerCase()] ?? entity;
+    });
+}

package/src/providers/odoo/executors.d.ts

@@ -0,0 +1,3 @@
+import type { CredentialValidators, ProviderExecutors } from "../../core/types.ts";
+export declare const executors: ProviderExecutors;
+export declare const credentialValidators: CredentialValidators;

package/src/providers/odoo/executors.js

@@ -0,0 +1,32 @@
+import { isPrivateNetworkAccessAllowed } from "../../core/request.js";
+import { createProviderFetch, defineProviderExecutors, ProviderRequestError, providerInputError, requireCustomCredential, } from "../provider-runtime.js";
+import { createOdooContext, odooActionHandlers } from "./runtime.js";
+export const executors = defineProviderExecutors({
+    service: "odoo",
+    handlers: odooActionHandlers,
+    allowPrivateNetwork: isPrivateNetworkAccessAllowed,
+    async createContext(context, fetcher) {
+        const credential = await requireCustomCredential(context, "odoo");
+        return createOdooContext(credential.values, fetcher, context.signal);
+    },
+});
+export const credentialValidators = {
+    async customCredential(input, { fetcher, signal }) {
+        const guardedFetcher = createProviderFetch({ fetch: fetcher, allowPrivateNetwork: isPrivateNetworkAccessAllowed });
+        try {
+            const context = await createOdooContext(input.values, guardedFetcher, signal);
+            return {
+                profile: {
+                    accountId: `${context.endpoint}:${context.database}:${context.uid}`,
+                    displayName: `${context.username} (${context.database})`,
+                },
+            };
+        }
+        catch (error) {
+            if (error instanceof ProviderRequestError && (error.status === 401 || error.status === 403)) {
+                throw providerInputError(error.message);
+            }
+            throw error;
+        }
+    },
+};

package/src/providers/odoo/runtime.d.ts

@@ -0,0 +1,16 @@
+import type { ProviderActionHandlers } from "../provider-runtime.ts";
+interface OdooConnection {
+    endpoint: string;
+    database: string;
+    username: string;
+    password: string;
+    fetcher: typeof fetch;
+    signal?: AbortSignal;
+}
+export interface OdooActionContext extends OdooConnection {
+    uid: number;
+}
+type OdooActionHandler = (input: Record<string, unknown>, context: OdooActionContext) => Promise<unknown>;
+export declare const odooActionHandlers: ProviderActionHandlers<"odoo", OdooActionHandler>;
+export declare function createOdooContext(values: Record<string, string>, fetcher: typeof fetch, signal?: AbortSignal): Promise<OdooActionContext>;
+export {};

package/src/providers/odoo/runtime.js

@@ -0,0 +1,140 @@
+import { compactObject, looseArray, optionalInteger, optionalRecord, optionalString, recordOrEmpty, requiredRawString, } from "../../core/cast.js";
+import { assertPublicHttpUrl, isPrivateNetworkAccessAllowed } from "../../core/request.js";
+import { ProviderRequestError, providerInputError, providerResponseError, providerUserAgent, readProviderJsonBody, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+export const odooActionHandlers = {
+    async search({ model, domain, limit, offset, order, context }, connection) {
+        return {
+            ids: await executeOdoo(connection, model, "search", [domain], { limit: limit ?? 100, offset, order, context }),
+        };
+    },
+    async read({ model, ids, fields, context }, connection) {
+        return { records: await executeOdoo(connection, model, "read", [ids], { fields, context }) };
+    },
+    async search_read({ model, domain, fields, limit, offset, order, context }, connection) {
+        return {
+            records: await executeOdoo(connection, model, "search_read", [domain], {
+                fields,
+                limit: limit ?? 100,
+                offset,
+                order,
+                context,
+            }),
+        };
+    },
+    async search_count({ model, domain, context }, connection) {
+        return { count: await executeOdoo(connection, model, "search_count", [domain], { context }) };
+    },
+    async fields_get({ model, fields, attributes, context }, connection) {
+        return {
+            fields: await executeOdoo(connection, model, "fields_get", [], { allfields: fields, attributes, context }),
+        };
+    },
+    async create({ model, values, context }, connection) {
+        return { id: await executeOdoo(connection, model, "create", [values], { context }) };
+    },
+    async write({ model, ids, values, context }, connection) {
+        return { success: await executeOdoo(connection, model, "write", [ids, values], { context }) };
+    },
+    async unlink({ model, ids, context }, connection) {
+        return { success: await executeOdoo(connection, model, "unlink", [ids], { context }) };
+    },
+    async execute_kw({ model, method, args, kwargs }, connection) {
+        return {
+            result: await executeOdoo(connection, model, requiredInputString(method, "method"), looseArray(args), recordOrEmpty(kwargs)),
+        };
+    },
+};
+export async function createOdooContext(values, fetcher, signal) {
+    const allowPrivateNetwork = isPrivateNetworkAccessAllowed();
+    const url = assertPublicHttpUrl(requiredInputString(values.baseUrl, "baseUrl"), {
+        fieldName: "baseUrl",
+        createError: providerInputError,
+        allowPrivateNetwork,
+    });
+    if (url.protocol !== "https:" && !allowPrivateNetwork) {
+        throw providerInputError("baseUrl must use HTTPS unless the self-hosted runtime enables OOMOL_CONNECT_ALLOW_PRIVATE_NETWORK");
+    }
+    if (url.username || url.password || url.search || url.hash) {
+        throw providerInputError("baseUrl must not contain credentials, a query, or a fragment");
+    }
+    url.pathname = `${url.pathname.replace(/\/+$/, "")}/jsonrpc`;
+    const password = requiredRawString(values.password, "password", providerInputError);
+    if (!password) {
+        throw providerInputError("password is required");
+    }
+    const connection = {
+        endpoint: url.toString(),
+        database: requiredInputString(values.database, "database"),
+        username: requiredInputString(values.username, "username"),
+        password,
+        fetcher,
+        signal,
+    };
+    const result = await requestOdooRpc(connection, "common", "authenticate", [
+        connection.database,
+        connection.username,
+        password,
+        {},
+    ]);
+    if (result === false) {
+        throw new ProviderRequestError(401, "Odoo authentication failed. Check the database, username, and password or API key.");
+    }
+    const uid = optionalInteger(result);
+    if (uid === undefined || uid <= 0) {
+        throw providerResponseError("Odoo authentication returned an invalid user ID");
+    }
+    return { ...connection, uid };
+}
+function executeOdoo(connection, model, method, args, kwargs) {
+    return requestOdooRpc(connection, "object", "execute_kw", [
+        connection.database,
+        connection.uid,
+        connection.password,
+        requiredInputString(model, "model"),
+        method,
+        args,
+        compactObject(kwargs),
+    ]);
+}
+function requestOdooRpc(connection, service, method, args) {
+    return runProviderRequest({ signal: connection.signal, label: "Odoo" }, async (signal) => {
+        const response = await connection.fetcher(connection.endpoint, {
+            method: "POST",
+            headers: { "content-type": "application/json", accept: "application/json", "user-agent": providerUserAgent },
+            body: JSON.stringify({ jsonrpc: "2.0", method: "call", params: { service, method, args }, id: 1 }),
+            // RPC credentials are in the body and must not be forwarded to a redirect target.
+            redirect: "manual",
+            signal,
+        });
+        if (!response.ok) {
+            throw new ProviderRequestError(response.status, `Odoo request failed with HTTP ${response.status}`);
+        }
+        const payload = requiredResponseRecord(await readProviderJsonBody(response, {
+            emptyBody: null,
+            invalidJsonMessage: "Odoo returned an invalid JSON-RPC response",
+        }), "Odoo response");
+        if (payload.jsonrpc !== "2.0" || payload.id !== 1) {
+            throw providerResponseError("Odoo returned an invalid JSON-RPC envelope");
+        }
+        if (payload.error !== undefined) {
+            const error = requiredResponseRecord(payload.error, "Odoo RPC error");
+            const data = optionalRecord(error.data);
+            const name = optionalString(data?.name);
+            const message = optionalString(data?.message) ?? optionalString(error.message) ?? "Odoo RPC request failed";
+            const status = name === "odoo.exceptions.AccessDenied"
+                ? 401
+                : name === "odoo.exceptions.AccessError"
+                    ? 403
+                    : name === "odoo.exceptions.UserError" ||
+                        name === "odoo.exceptions.ValidationError" ||
+                        name === "odoo.exceptions.MissingError"
+                        ? 400
+                        : 502;
+            throw new ProviderRequestError(status, message);
+        }
+        if (!Object.hasOwn(payload, "result")) {
+            throw providerResponseError("Odoo response is missing the RPC result");
+        }
+        return payload.result;
+    });
+}

package/src/providers/one_drive/executors.d.ts

@@ -1,4 +1,6 @@
 import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+import type { IntegrationDefinition } from "../../triggers/common/integration.ts";
+import type { PollDefinition } from "../../triggers/common/poll.ts";
 import type { ProviderActionHandlers } from "../provider-runtime.ts";
 import type { OAuthProviderContext } from "../provider-runtime.ts";
 type OneDriveRuntimeDeps = OAuthProviderContext;
@@ -23,4 +25,5 @@ export declare const proxy: ProviderProxyExecutor;
 export declare const credentialValidators: CredentialValidators;
 export declare function oneDriveJsonRequest<T>(pathOrUrl: string, input: OneDriveRequestInput): Promise<T>;
 export declare function assertOneDriveResponse(response: Response): Promise<void>;
+export declare const triggers: readonly (IntegrationDefinition | PollDefinition)[];
 export {};

package/src/providers/one_drive/executors.js

@@ -2,6 +2,7 @@ import { Buffer } from "node:buffer";
 import { compactObject, requiredRecord } from "../../core/cast.js";
 import { readBoundedResponseBytes } from "../../core/request.js";
 import { defineOAuthProviderExecutors, defineProviderProxy, ProviderRequestError, readTransitFileInput, } from "../provider-runtime.js";
+import { oneDriveItemChanged } from "./trigger-on-item-changed.js";
 const graphBaseUrl = "https://graph.microsoft.com/v1.0";
 const graphOrigin = new URL(graphBaseUrl).origin;
 const oneDriveUploadChunkSizeBytes = 10 * 1024 * 1024;
@@ -1194,3 +1195,4 @@ function toArrayBuffer(bytes) {
     }
     return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
 }
+export const triggers = [oneDriveItemChanged];

package/src/providers/one_drive/trigger-on-item-changed.d.ts

@@ -0,0 +1,2 @@
+import type { PollDefinition } from "../../triggers/common/poll.ts";
+export declare const oneDriveItemChanged: PollDefinition;

package/src/providers/one_drive/trigger-on-item-changed.definition.d.ts

@@ -0,0 +1,4 @@
+import type { TriggerKeySnapshot } from "../../triggers/common/types.ts";
+export declare const snapshot: TriggerKeySnapshot & {
+    readonly type: "poll";
+};

package/src/providers/one_drive/trigger-on-item-changed.definition.js

@@ -0,0 +1,63 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+const eventSchema = s.object({
+    changeType: s.stringEnum(["created", "updated", "deleted"]),
+    createdDateTime: { type: ["string", "null"] },
+    driveId: { type: ["string", "null"] },
+    eTag: { type: ["string", "null"] },
+    itemId: s.string(),
+    itemType: s.stringEnum(["file", "folder"]),
+    lastModifiedDateTime: { type: ["string", "null"] },
+    mimeType: { type: ["string", "null"] },
+    name: s.string(),
+    parentFolderId: { type: ["string", "null"] },
+    size: { type: ["number", "null"] },
+    webUrl: s.string(),
+}, {
+    additionalProperties: false,
+    required: [
+        "itemId",
+        "name",
+        "changeType",
+        "itemType",
+        "size",
+        "mimeType",
+        "webUrl",
+        "parentFolderId",
+        "driveId",
+        "createdDateTime",
+        "lastModifiedDateTime",
+        "eTag",
+    ],
+});
+export const snapshot = {
+    configInputs: [
+        {
+            handle: "events",
+            jsonSchema: s.array(s.stringEnum(["created", "updated", "deleted"]), { minItems: 1, uniqueItems: true }),
+            nullable: false,
+            value: ["created", "updated"],
+        },
+        { handle: "itemId", jsonSchema: s.string(), nullable: false, value: "" },
+        {
+            handle: "itemTypes",
+            jsonSchema: s.array(s.stringEnum(["file", "folder"]), { minItems: 1, uniqueItems: true }),
+            nullable: false,
+            value: ["file"],
+        },
+        {
+            handle: "maxItemsPerPoll",
+            jsonSchema: s.integer({ maximum: 200, minimum: 1 }),
+            nullable: false,
+            value: 50,
+        },
+        { handle: "parentFolderId", jsonSchema: s.string(), nullable: false, value: "" },
+    ],
+    definitionVersion: 2,
+    description: "Polls the OneDrive change feed and triggers when a file or folder is created, updated or deleted.",
+    displayName: "File or Folder Changed",
+    key: "one_drive.on_item_changed",
+    name: "on_item_changed",
+    outputs: [{ handle: "events", jsonSchema: s.array(eventSchema), nullable: false }],
+    provider: "one_drive",
+    type: "poll",
+};