ntion 0.1.0

package/dist/notion/markdown.js

@@ -0,0 +1,237 @@
+const MAX_RICH_TEXT_CHARS = 1800;
+function chunkText(content) {
+    if (content.length <= MAX_RICH_TEXT_CHARS) {
+        return [content];
+    }
+    const chunks = [];
+    for (let index = 0; index < content.length; index += MAX_RICH_TEXT_CHARS) {
+        chunks.push(content.slice(index, index + MAX_RICH_TEXT_CHARS));
+    }
+    return chunks;
+}
+function toRichText(content) {
+    const normalized = content.length > 0 ? content : " ";
+    return chunkText(normalized).map((chunk) => ({
+        type: "text",
+        text: {
+            content: chunk,
+        },
+    }));
+}
+function paragraphBlock(text) {
+    return {
+        object: "block",
+        type: "paragraph",
+        paragraph: {
+            rich_text: toRichText(text),
+        },
+    };
+}
+function headingBlock(level, text) {
+    const type = `heading_${level}`;
+    return {
+        object: "block",
+        type,
+        [type]: {
+            rich_text: toRichText(text),
+        },
+    };
+}
+function bulletedItemBlock(text) {
+    return {
+        object: "block",
+        type: "bulleted_list_item",
+        bulleted_list_item: {
+            rich_text: toRichText(text),
+        },
+    };
+}
+function numberedItemBlock(text) {
+    return {
+        object: "block",
+        type: "numbered_list_item",
+        numbered_list_item: {
+            rich_text: toRichText(text),
+        },
+    };
+}
+function todoBlock(text, checked) {
+    return {
+        object: "block",
+        type: "to_do",
+        to_do: {
+            rich_text: toRichText(text),
+            checked,
+        },
+    };
+}
+function quoteBlock(text) {
+    return {
+        object: "block",
+        type: "quote",
+        quote: {
+            rich_text: toRichText(text),
+        },
+    };
+}
+function dividerBlock() {
+    return {
+        object: "block",
+        type: "divider",
+        divider: {},
+    };
+}
+function normalizeCodeLanguage(raw) {
+    const language = raw.trim().toLowerCase();
+    if (!language) {
+        return "plain text";
+    }
+    switch (language) {
+        case "ts":
+        case "typescript":
+            return "typescript";
+        case "js":
+        case "javascript":
+            return "javascript";
+        case "py":
+        case "python":
+            return "python";
+        case "sh":
+        case "bash":
+        case "shell":
+            return "shell";
+        case "json":
+            return "json";
+        case "sql":
+            return "sql";
+        case "yaml":
+        case "yml":
+            return "yaml";
+        case "md":
+        case "markdown":
+            return "markdown";
+        case "html":
+            return "html";
+        case "css":
+            return "css";
+        case "go":
+            return "go";
+        case "java":
+            return "java";
+        case "ruby":
+            return "ruby";
+        case "rust":
+            return "rust";
+        default:
+            return "plain text";
+    }
+}
+function codeBlock(text, language) {
+    return {
+        object: "block",
+        type: "code",
+        code: {
+            rich_text: toRichText(text),
+            language,
+        },
+    };
+}
+function isDivider(trimmed) {
+    return trimmed === "---" || trimmed === "***" || trimmed === "___";
+}
+export function markdownToBlocks(markdown) {
+    const normalized = markdown.replace(/\r\n/g, "\n");
+    const lines = normalized.split("\n");
+    const blocks = [];
+    let paragraphLines = [];
+    const flushParagraph = () => {
+        if (paragraphLines.length === 0) {
+            return;
+        }
+        const text = paragraphLines.join("\n").trim();
+        paragraphLines = [];
+        if (text.length > 0) {
+            blocks.push(paragraphBlock(text));
+        }
+    };
+    for (let index = 0; index < lines.length;) {
+        const line = lines[index];
+        const trimmed = line.trim();
+        if (trimmed.startsWith("```")) {
+            flushParagraph();
+            const language = normalizeCodeLanguage(trimmed.slice(3));
+            index += 1;
+            const codeLines = [];
+            while (index < lines.length && !lines[index].trim().startsWith("```")) {
+                codeLines.push(lines[index]);
+                index += 1;
+            }
+            if (index < lines.length && lines[index].trim().startsWith("```")) {
+                index += 1;
+            }
+            blocks.push(codeBlock(codeLines.join("\n"), language));
+            continue;
+        }
+        if (trimmed.length === 0) {
+            flushParagraph();
+            index += 1;
+            continue;
+        }
+        if (isDivider(trimmed)) {
+            flushParagraph();
+            blocks.push(dividerBlock());
+            index += 1;
+            continue;
+        }
+        const headingMatch = trimmed.match(/^(#{1,3})\s+(.+)$/);
+        if (headingMatch) {
+            flushParagraph();
+            const level = headingMatch[1].length;
+            blocks.push(headingBlock(level, headingMatch[2]));
+            index += 1;
+            continue;
+        }
+        const todoMatch = trimmed.match(/^[-*]\s+\[( |x|X)\]\s+(.+)$/);
+        if (todoMatch) {
+            flushParagraph();
+            blocks.push(todoBlock(todoMatch[2], todoMatch[1].toLowerCase() === "x"));
+            index += 1;
+            continue;
+        }
+        const quoteMatch = trimmed.match(/^>\s?(.*)$/);
+        if (quoteMatch) {
+            flushParagraph();
+            const quoteLines = [quoteMatch[1]];
+            index += 1;
+            while (index < lines.length) {
+                const next = lines[index].trim();
+                const nextMatch = next.match(/^>\s?(.*)$/);
+                if (!nextMatch) {
+                    break;
+                }
+                quoteLines.push(nextMatch[1]);
+                index += 1;
+            }
+            blocks.push(quoteBlock(quoteLines.join("\n")));
+            continue;
+        }
+        const bulletMatch = trimmed.match(/^[-*+]\s+(.+)$/);
+        if (bulletMatch) {
+            flushParagraph();
+            blocks.push(bulletedItemBlock(bulletMatch[1]));
+            index += 1;
+            continue;
+        }
+        const numberedMatch = trimmed.match(/^\d+\.\s+(.+)$/);
+        if (numberedMatch) {
+            flushParagraph();
+            blocks.push(numberedItemBlock(numberedMatch[1]));
+            index += 1;
+            continue;
+        }
+        paragraphLines.push(line);
+        index += 1;
+    }
+    flushParagraph();
+    return blocks;
+}

package/dist/notion/properties.d.ts

@@ -0,0 +1,7 @@
+export declare function normalizePropertyValue(property: Record<string, unknown>): unknown;
+export declare function normalizeProperties(properties: Record<string, unknown>): Record<string, unknown>;
+export declare function buildPropertyValueByType(type: string, value: unknown): Record<string, unknown>;
+export declare function buildPropertiesPayloadGeneric(patch: Record<string, unknown>, schemaProperties: Record<string, {
+    id: string;
+    type: string;
+}>): Record<string, unknown>;

package/dist/notion/properties.js

@@ -0,0 +1,267 @@
+import { CliError } from "../errors/cli-error.js";
+function readPlainText(rich) {
+    if (!rich || rich.length === 0) {
+        return "";
+    }
+    return rich
+        .map((fragment) => {
+        const plainText = fragment.plain_text;
+        if (typeof plainText === "string") {
+            return plainText;
+        }
+        const text = fragment.text;
+        return text?.content ?? "";
+    })
+        .join("");
+}
+function normalizeFormula(formula) {
+    const type = formula.type;
+    if (typeof type !== "string") {
+        return formula;
+    }
+    return formula[type];
+}
+function normalizeRollup(rollup) {
+    const type = rollup.type;
+    if (typeof type !== "string") {
+        return rollup;
+    }
+    if (type === "array") {
+        const arrayValue = rollup.array;
+        if (!Array.isArray(arrayValue)) {
+            return [];
+        }
+        return arrayValue.map((entry) => normalizePropertyValue(entry));
+    }
+    return rollup[type];
+}
+export function normalizePropertyValue(property) {
+    const type = property.type;
+    if (typeof type !== "string") {
+        return property;
+    }
+    switch (type) {
+        case "title": {
+            const title = property.title;
+            return readPlainText(title);
+        }
+        case "rich_text": {
+            const richText = property.rich_text;
+            return readPlainText(richText);
+        }
+        case "status": {
+            const status = property.status;
+            return status?.name ?? null;
+        }
+        case "select": {
+            const select = property.select;
+            return select?.name ?? null;
+        }
+        case "multi_select": {
+            const selections = property.multi_select;
+            return selections?.map((item) => item.name).filter((value) => Boolean(value)) ?? [];
+        }
+        case "date": {
+            const date = property.date;
+            return date;
+        }
+        case "relation": {
+            const relation = property.relation;
+            return relation?.map((entry) => entry.id).filter((value) => Boolean(value)) ?? [];
+        }
+        case "people": {
+            const people = property.people;
+            return people?.map((person) => person.id).filter((value) => Boolean(value)) ?? [];
+        }
+        case "checkbox":
+        case "number":
+        case "url":
+        case "email":
+        case "phone_number":
+            return property[type] ?? null;
+        case "files": {
+            const files = property.files;
+            return (files ?? []).map((file) => ({
+                name: file.name ?? null,
+                type: file.type ?? null,
+                url: file.type === "external" ? file.external?.url ?? null : file.file?.url ?? null,
+            }));
+        }
+        case "formula": {
+            const formula = property.formula;
+            return normalizeFormula(formula);
+        }
+        case "rollup": {
+            const rollup = property.rollup;
+            return normalizeRollup(rollup);
+        }
+        case "created_time":
+        case "last_edited_time":
+            return property[type] ?? null;
+        default:
+            return property[type] ?? null;
+    }
+}
+export function normalizeProperties(properties) {
+    const normalized = {};
+    for (const [name, property] of Object.entries(properties)) {
+        if (property && typeof property === "object") {
+            normalized[name] = normalizePropertyValue(property);
+        }
+    }
+    return normalized;
+}
+function normalizeDateInput(value) {
+    if (value === null) {
+        return null;
+    }
+    if (typeof value === "string") {
+        return { start: value };
+    }
+    if (value && typeof value === "object") {
+        const candidate = value;
+        if (typeof candidate.start !== "string") {
+            throw new CliError("invalid_input", "Date value must include a string \"start\" field.");
+        }
+        return {
+            start: candidate.start,
+            end: typeof candidate.end === "string" || candidate.end === null ? candidate.end : undefined,
+            time_zone: typeof candidate.time_zone === "string" || candidate.time_zone === null
+                ? candidate.time_zone
+                : undefined,
+        };
+    }
+    throw new CliError("invalid_input", "Invalid date value.");
+}
+function asStringArray(value, label) {
+    if (!Array.isArray(value)) {
+        throw new CliError("invalid_input", `${label} expects an array of strings.`);
+    }
+    const items = value.filter((item) => typeof item === "string" && item.length > 0);
+    if (items.length !== value.length) {
+        throw new CliError("invalid_input", `${label} expects an array of strings.`);
+    }
+    return items;
+}
+function toRichText(content) {
+    return [{ type: "text", text: { content } }];
+}
+function isRawPropertyPayload(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const keys = Object.keys(value);
+    const known = new Set([
+        "title",
+        "rich_text",
+        "status",
+        "select",
+        "multi_select",
+        "date",
+        "relation",
+        "people",
+        "checkbox",
+        "number",
+        "url",
+        "email",
+        "phone_number",
+        "files",
+        "formula",
+    ]);
+    return keys.some((key) => known.has(key));
+}
+export function buildPropertyValueByType(type, value) {
+    switch (type) {
+        case "title": {
+            if (typeof value !== "string") {
+                throw new CliError("invalid_input", "Title properties require string values.");
+            }
+            return { title: toRichText(value) };
+        }
+        case "rich_text": {
+            if (typeof value !== "string") {
+                throw new CliError("invalid_input", "Rich text properties require string values.");
+            }
+            return { rich_text: toRichText(value) };
+        }
+        case "status": {
+            if (typeof value !== "string") {
+                throw new CliError("invalid_input", "Status properties require a string status name.");
+            }
+            return { status: { name: value } };
+        }
+        case "select": {
+            if (typeof value !== "string") {
+                throw new CliError("invalid_input", "Select properties require a string option name.");
+            }
+            return { select: { name: value } };
+        }
+        case "multi_select": {
+            const names = asStringArray(value, "multi_select");
+            return { multi_select: names.map((name) => ({ name })) };
+        }
+        case "date": {
+            const normalized = normalizeDateInput(value);
+            return { date: normalized };
+        }
+        case "relation": {
+            const ids = asStringArray(value, "relation");
+            return { relation: ids.map((id) => ({ id })) };
+        }
+        case "people": {
+            const ids = asStringArray(value, "people");
+            return { people: ids.map((id) => ({ id })) };
+        }
+        case "checkbox": {
+            if (typeof value !== "boolean") {
+                throw new CliError("invalid_input", "Checkbox properties require boolean values.");
+            }
+            return { checkbox: value };
+        }
+        case "number": {
+            if (typeof value !== "number") {
+                throw new CliError("invalid_input", "Number properties require numeric values.");
+            }
+            return { number: value };
+        }
+        case "url": {
+            if (typeof value !== "string" && value !== null) {
+                throw new CliError("invalid_input", "URL properties require string or null values.");
+            }
+            return { url: value };
+        }
+        case "email": {
+            if (typeof value !== "string" && value !== null) {
+                throw new CliError("invalid_input", "Email properties require string or null values.");
+            }
+            return { email: value };
+        }
+        case "phone_number": {
+            if (typeof value !== "string" && value !== null) {
+                throw new CliError("invalid_input", "Phone number properties require string or null values.");
+            }
+            return { phone_number: value };
+        }
+        default: {
+            if (typeof value === "string") {
+                return { rich_text: toRichText(value) };
+            }
+            return { rich_text: toRichText(JSON.stringify(value)) };
+        }
+    }
+}
+export function buildPropertiesPayloadGeneric(patch, schemaProperties) {
+    const payload = {};
+    for (const [propertyName, value] of Object.entries(patch)) {
+        const schemaEntry = schemaProperties[propertyName];
+        if (!schemaEntry) {
+            throw new CliError("invalid_input", `Unknown property \"${propertyName}\" for this data source. Use data-sources get to inspect available properties.`);
+        }
+        if (isRawPropertyPayload(value)) {
+            payload[propertyName] = value;
+            continue;
+        }
+        payload[propertyName] = buildPropertyValueByType(schemaEntry.type, value);
+    }
+    return payload;
+}

package/dist/notion/repository.d.ts

@@ -0,0 +1,142 @@
+import { AppConfig } from "../config/types.js";
+import { NotionClientAdapter } from "./client.js";
+export interface PaginationResult {
+    has_more: boolean;
+    next_cursor: string | null;
+    returned: number;
+}
+export interface QueryPagesInput {
+    dataSourceId: string;
+    limit: number;
+    cursor?: string;
+    filter?: Record<string, unknown>;
+    sorts?: Array<Record<string, unknown>>;
+    view: "compact" | "full";
+    fields?: string[];
+}
+export interface RepositoryContext {
+    notion: NotionClientAdapter;
+    config: AppConfig;
+    saveConfig: (config: AppConfig) => Promise<void>;
+}
+export interface SearchWorkspaceInput {
+    query: string;
+    limit: number;
+    cursor?: string;
+    scope?: string;
+    createdAfter?: string;
+    createdBefore?: string;
+    editedAfter?: string;
+    editedBefore?: string;
+    createdBy?: string;
+    object?: "page" | "data_source";
+    scanLimit: number;
+}
+export interface SearchWorkspaceResult {
+    results: Record<string, unknown>[];
+    pagination: PaginationResult;
+    scan_count: number;
+}
+export interface CreateBulkInput {
+    parentDataSourceId: string;
+    items: Array<{
+        propertiesPatch: Record<string, unknown>;
+    }>;
+    view: "compact" | "full";
+    fields?: string[];
+    concurrency: number;
+}
+export declare function searchWorkspace(notion: NotionClientAdapter, input: SearchWorkspaceInput): Promise<SearchWorkspaceResult>;
+export declare function listDataSources(notion: NotionClientAdapter, input: {
+    query?: string;
+    limit: number;
+    cursor?: string;
+}): Promise<{
+    data_sources: Record<string, unknown>[];
+    pagination: PaginationResult;
+}>;
+export declare function getDataSource(notion: NotionClientAdapter, dataSourceId: string, view: "compact" | "full"): Promise<Record<string, unknown>>;
+export declare function getDataSourceSchema(notion: NotionClientAdapter, dataSourceId: string): Promise<Record<string, unknown>>;
+export declare function queryDataSourcePages(ctx: RepositoryContext, input: QueryPagesInput): Promise<{
+    records: Record<string, unknown>[];
+    pagination: PaginationResult;
+}>;
+export declare function getPage(notion: NotionClientAdapter, pageId: string, view: "compact" | "full", fields?: string[]): Promise<Record<string, unknown>>;
+export declare function createPage(ctx: RepositoryContext, input: {
+    parentDataSourceId: string;
+    propertiesPatch: Record<string, unknown>;
+    view: "compact" | "full";
+    fields?: string[];
+}): Promise<Record<string, unknown>>;
+export declare function createPagesBulk(ctx: RepositoryContext, input: CreateBulkInput): Promise<Record<string, unknown>>;
+export declare function updatePage(ctx: RepositoryContext, input: {
+    pageId: string;
+    patch: Record<string, unknown>;
+    view: "compact" | "full";
+    fields?: string[];
+}): Promise<Record<string, unknown>>;
+export declare function archivePage(ctx: RepositoryContext, input: {
+    pageId: string;
+    view: "compact" | "full";
+    fields?: string[];
+}): Promise<Record<string, unknown>>;
+export declare function unarchivePage(ctx: RepositoryContext, input: {
+    pageId: string;
+    view: "compact" | "full";
+    fields?: string[];
+}): Promise<Record<string, unknown>>;
+export declare function setRelation(ctx: RepositoryContext, args: {
+    fromId: string;
+    toId: string;
+    property: string;
+    mode: "add" | "remove";
+    view: "compact" | "full";
+    fields?: string[];
+}): Promise<Record<string, unknown>>;
+export interface BlockSelector {
+    where?: {
+        type?: string;
+        text_contains?: string;
+        parent_id?: string;
+    };
+    nth?: number;
+    from?: "start" | "end";
+}
+export type BlockInsertPosition = {
+    type: "start";
+} | {
+    type: "end";
+} | {
+    type: "after_block";
+    after_block: {
+        id: string;
+    };
+};
+export type BlockReadFormat = "compact" | "full" | "markdown";
+export declare function getBlocks(notion: NotionClientAdapter, pageOrBlockId: string, maxBlocks: number, depth: number, view: BlockReadFormat): Promise<Record<string, unknown>>;
+export declare function insertBlocks(notion: NotionClientAdapter, args: {
+    parentId: string;
+    blocks: Array<Record<string, unknown>>;
+    position: BlockInsertPosition;
+    dryRun: boolean;
+}): Promise<Record<string, unknown>>;
+export declare function appendBlocks(notion: NotionClientAdapter, args: {
+    parentId: string;
+    blocks: Array<Record<string, unknown>>;
+    dryRun: boolean;
+}): Promise<Record<string, unknown>>;
+export declare function selectBlocks(notion: NotionClientAdapter, args: {
+    scopeId: string;
+    selector: BlockSelector;
+    maxBlocks: number;
+}): Promise<Record<string, unknown>>;
+export declare function replaceBlockRange(notion: NotionClientAdapter, args: {
+    scopeId: string;
+    startSelector: BlockSelector;
+    endSelector: BlockSelector;
+    blocks: Array<Record<string, unknown>>;
+    inclusiveStart: boolean;
+    inclusiveEnd: boolean;
+    dryRun: boolean;
+    maxBlocks: number;
+}): Promise<Record<string, unknown>>;