@notionhq/custom-blocks 0.0.78 → 0.1.0

package/bin/cli/deploy.js

@@ -1,109 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { existsSync, statSync } from "node:fs";
-import { resolve as resolvePath } from "node:path";
-import { extractId, formatUuid } from "./ids.js";
-import { mergeTarget, readTarget, writeTarget } from "./target.js";
-/**
- * The `ntn custom deploy` endpoint is feature-gated. When the gate is off,
- * the API returns a 403 with `code: "restricted_resource"` and message
- * `"Endpoint unavailable."` — but the user sees a raw blob and no actionable
- * hint. Match any of the wire fingerprints so we can nudge regardless of
- * which surface ntn echoed.
- */
-const FEATURE_GATE_PATTERN = /restricted_resource|Endpoint unavailable|403\s*Forbidden/i;
-const FEATURE_GATE_HINT = "Please ensure that the feature gate custom_blocks is enabled.";
-/**
- * Run `ntn custom deploy --block <id> <dist>` for each block. Block IDs come
- * from --block flags if any, otherwise from `.notion/target.json`. On
- * success, --block IDs (and --env) are merged back into target.json so it
- * accumulates deploy targets across runs.
- *
- * This wrapper does NOT build — the package manager is the user's choice.
- */
-export function deploy(options) {
-    const existingTarget = readTarget();
-    const flagBlockIds = (options.blockIds ?? []).map(id => formatUuid(extractId(id)));
-    const blockIds = flagBlockIds.length > 0 ? flagBlockIds : (existingTarget?.block_id ?? []);
-    if (blockIds.length === 0) {
-        console.error("Error: no blocks to deploy to — pass --block <id>, or run 'ncblock connect --block <id>' first to populate .notion/target.json.\n");
-        process.exit(1);
-    }
-    const distPath = resolvePath(process.cwd(), options.distPath);
-    if (!existsSync(distPath) || !statSync(distPath).isDirectory()) {
-        console.error(`Error: <dist-path> '${options.distPath}' does not exist or is not a directory.\n`);
-        console.error("Run your project's build script first (e.g. `npm run build`), then pass the resulting directory.");
-        process.exit(1);
-    }
-    const env = options.env ?? existingTarget?.env ?? "production";
-    if (options.dryRun) {
-        const payload = {
-            action: "deploy",
-            env,
-            dist_path: distPath,
-            commands: blockIds.map(id => buildDeployCommand(env, id, distPath)),
-        };
-        if (options.jsonOutput) {
-            console.log(JSON.stringify(payload, null, "\t"));
-        }
-        else {
-            console.log("\nDry run — would run:\n");
-            for (const cmd of payload.commands) {
-                console.log(`  ${cmd}`);
-            }
-            console.log("");
-        }
-        return;
-    }
-    const results = [];
-    for (const id of blockIds) {
-        const cmd = buildDeployCommand(env, id, distPath);
-        if (!options.jsonOutput) {
-            console.log(`\n→ ${cmd}\n`);
-        }
-        // Capture both streams (rather than inherit) so we can scan for the
-        // feature-gate fingerprint and print an actionable hint. We still echo
-        // everything back to the user so the live output looks the same.
-        const result = spawnSync(cmd, {
-            shell: true,
-            stdio: ["inherit", "pipe", "pipe"],
-            encoding: "utf-8",
-        });
-        const childStdout = result.stdout ?? "";
-        const childStderr = result.stderr ?? "";
-        if (!options.jsonOutput) {
-            if (childStdout) {
-                process.stdout.write(childStdout);
-            }
-            if (childStderr) {
-                process.stderr.write(childStderr);
-            }
-        }
-        if (result.status !== 0) {
-            if (FEATURE_GATE_PATTERN.test(childStdout + childStderr)) {
-                process.stderr.write(`\n${FEATURE_GATE_HINT}\n\n`);
-            }
-            process.exit(result.status ?? 1);
-        }
-        results.push({ block_id: id, command: cmd });
-    }
-    // Record the successful deploy back into target.json so subsequent
-    // `connect` / `deploy` calls remember where this got shipped.
-    const merged = mergeTarget(existingTarget, {
-        env: options.env ?? existingTarget?.env,
-        block_id: blockIds,
-    });
-    writeTarget(merged);
-    if (options.jsonOutput) {
-        console.log(JSON.stringify({ action: "deploy", env, deployed: results, target: merged }, null, "\t"));
-    }
-}
-function buildDeployCommand(env, blockId, distPath) {
-    const prefix = env && env !== "production" ? `NOTION_KEYRING=0 ntn --env ${env}` : "ntn";
-    return `${prefix} custom deploy --block ${blockId} ${shellQuote(distPath)}`;
-}
-function shellQuote(s) {
-    if (!/[\s"'`$\\]/.test(s)) {
-        return s;
-    }
-    return `'${s.replace(/'/g, "'\\''")}'`;
-}

package/bin/cli/ids.js

@@ -1,13 +0,0 @@
-/** Extract a 32-char hex ID from a Notion URL or raw UUID. */
-export function extractId(input) {
-    const match = input.match(/([a-f0-9]{32}|[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})/);
-    if (match) {
-        return match[1].replace(/-/g, "");
-    }
-    return input.replace(/-/g, "");
-}
-/** Format a 32-char hex string as a dashed UUID. */
-export function formatUuid(raw) {
-    const h = raw.replace(/-/g, "");
-    return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
-}

package/bin/cli/ntn.js

@@ -1,95 +0,0 @@
-import { execSync } from "node:child_process";
-import { readTarget } from "./target.js";
-/**
- * Resolve the active Notion env. An explicit `ENV=` always wins — that's the
- * escape hatch for "I know what target.json says, but run this one against X".
- * Otherwise target.json is the source of truth (every command merges into it,
- * and it's checked in alongside the project).
- */
-function resolveEnv() {
-    return process.env.ENV ?? readTarget()?.env;
-}
-/**
- * Shell command we nudge users toward when an `ntn api` call fails in a way
- * that suggests they're not logged in (404 on a known-public resource, missing
- * data sources on a real database). Mirrors `buildCommand`'s env handling.
- */
-export function loginHintCommand() {
-    const env = resolveEnv();
-    if (env && env !== "production") {
-        return `NOTION_KEYRING=0 ntn --env ${env} login`;
-    }
-    return "ntn login";
-}
-/**
- * The `ntn` invocation prefix with correct ENV handling.
- *
- * - env is unset or "production" → `ntn` (no keyring override)
- * - Any other env value          → `NOTION_KEYRING=0 ntn --env <env>`
- */
-function ntnPrefix() {
-    const env = resolveEnv();
-    if (env && env !== "production") {
-        return `NOTION_KEYRING=0 ntn --env ${env}`;
-    }
-    return "ntn";
-}
-/**
- * Build the `ntn api` command with correct ENV handling.
- *
- * - env is unset or "production" → `ntn api <path>` (no keyring override)
- * - Any other env value          → `NOTION_KEYRING=0 ntn --env <env> api <path>`
- */
-function buildCommand(apiPath) {
-    return `${ntnPrefix()} api ${apiPath}`;
-}
-/**
- * Call `ntn api <path>` and return the parsed JSON response.
- * Throws on non-zero exit or invalid JSON.
- */
-export function ntnApi(apiPath) {
-    const cmd = buildCommand(apiPath);
-    return run(cmd, apiPath);
-}
-/**
- * Call `ntn api -X PATCH <path> -d <json>` and return the parsed JSON response.
- * Throws on non-zero exit or invalid JSON.
- */
-export function ntnApiPatch(apiPath, body) {
-    const base = buildCommand(apiPath);
-    const cmd = `${base} -X PATCH -d ${shellEscape(JSON.stringify(body))}`;
-    return run(cmd, apiPath);
-}
-/**
- * Call `ntn api -X POST <path> -d <json>` and return the parsed JSON response.
- * Throws on non-zero exit or invalid JSON.
- */
-export function ntnApiPost(apiPath, body) {
-    const base = buildCommand(apiPath);
-    const cmd = `${base} -X POST -d ${shellEscape(JSON.stringify(body))}`;
-    return run(cmd, apiPath);
-}
-/**
- * Call `ntn workers capabilities list --json` and return the parsed JSON.
- * Throws on non-zero exit or invalid JSON. Reads the worker ID from the local
- * workers.json (same as the bare `ntn` command would).
- */
-export function ntnWorkersCapabilities() {
-    const cmd = `${ntnPrefix()} workers capabilities list --json`;
-    return run(cmd, "workers capabilities list");
-}
-function shellEscape(s) {
-    return `'${s.replace(/'/g, "'\\''")}'`;
-}
-function run(cmd, label) {
-    try {
-        const output = execSync(cmd, { encoding: "utf-8", stdio: "pipe" });
-        return JSON.parse(output);
-    }
-    catch (error) {
-        const stderr = error instanceof Error && "stderr" in error
-            ? error.stderr
-            : "";
-        throw new Error(`ntn api ${label} failed${stderr ? `:\n${stderr.toString().trim()}` : ""}`);
-    }
-}

package/bin/cli/pullData.js

@@ -1,76 +0,0 @@
-import { writeFileSync } from "node:fs";
-import { resolve as resolvePath } from "node:path";
-import { extractId, formatUuid } from "./ids.js";
-import { loginHintCommand, ntnApi, ntnApiPost } from "./ntn.js";
-const DEFAULT_LIMIT = 25;
-// The public data source query endpoint caps page_size at 100.
-const MAX_PAGE_SIZE = 100;
-function is404(error) {
-    return error instanceof Error && error.message.includes("404");
-}
-function plainText(items) {
-    if (!items?.length) {
-        return "Data source";
-    }
-    return items.map(t => t.plain_text ?? "").join("") || "Data source";
-}
-/**
- * Resolve an ID/URL to a data source ID. Tries `/v1/databases/<id>` first
- * (walks to its first data source), falling back to treating the ID as a data
- * source directly. Mirrors the resolution `pullManifest`/`classifyId` use.
- */
-function resolveDataSourceId(uuid) {
-    try {
-        console.error(`  Resolving database ${uuid}…`);
-        const db = ntnApi(`/v1/databases/${uuid}`);
-        if (db.object === "database") {
-            if (!db.data_sources?.length) {
-                throw new Error(`Database ${uuid} has no data sources. Confirm you're logged in to the right workspace with \`${loginHintCommand()}\`.`);
-            }
-            return formatUuid(db.data_sources[0].id);
-        }
-    }
-    catch (error) {
-        if (!is404(error)) {
-            throw error;
-        }
-    }
-    // Not a database — assume it already points at a data source. We don't GET
-    // it here; the schema fetch below will 404 clearly if it isn't one.
-    return uuid;
-}
-/**
- * Resolve an ID/URL to a data source, then emit its property schema plus the
- * first N rows as JSON. JSON goes to stdout (pipeable) unless `--out` is set;
- * progress chatter goes to stderr so it never pollutes the payload.
- */
-export function pullData(options) {
-    const uuid = formatUuid(extractId(options.idOrUrl));
-    const limit = Math.min(Math.max(1, options.limit ?? DEFAULT_LIMIT), MAX_PAGE_SIZE);
-    console.error(`\nResolving ${options.idOrUrl}…`);
-    const dataSourceId = resolveDataSourceId(uuid);
-    console.error(`  Fetching schema for data source ${dataSourceId}…`);
-    const schema = ntnApi(`/v1/data_sources/${dataSourceId}`);
-    const properties = schema.properties ?? {};
-    console.error(`  Querying ${limit} row(s)…`);
-    const query = ntnApiPost(`/v1/data_sources/${dataSourceId}/query`, {
-        page_size: limit,
-    });
-    const rows = query.results ?? [];
-    const payload = {
-        data_source_id: dataSourceId,
-        name: plainText(schema.title),
-        properties,
-        row_count: rows.length,
-        has_more: query.has_more ?? false,
-        rows,
-    };
-    const json = JSON.stringify(payload, null, "\t") + "\n";
-    if (options.out) {
-        const outPath = resolvePath(process.cwd(), options.out);
-        writeFileSync(outPath, json);
-        console.error(`\n✓ Wrote ${rows.length} row(s) from "${payload.name}" to ${options.out}\n`);
-        return;
-    }
-    process.stdout.write(json);
-}

package/bin/cli/pullManifest.js

@@ -1,158 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { resolve as resolvePath } from "node:path";
-import { NOTION_BUILTIN_PROPERTY_IDS } from "../src/bridge/dataSources/propertySchema.js";
-import { extractId, formatUuid } from "./ids.js";
-import { loginHintCommand, ntnApi } from "./ntn.js";
-import { mergeTarget, readTarget, writeTarget } from "./target.js";
-const MANIFEST_FILENAME = "custom_blocks.json";
-const BUILTIN_TYPES = new Set(NOTION_BUILTIN_PROPERTY_IDS);
-// ── Helpers ───────────────────────────────────────────────────────
-function deriveKey(name) {
-    return name
-        .toLowerCase()
-        .replace(/\s+/g, "_")
-        .replace(/[^a-z0-9_]/g, "");
-}
-function plainText(items) {
-    if (!items?.length) {
-        return "Data source";
-    }
-    return items.map(t => t.plain_text ?? "").join("") || "Data source";
-}
-function is404(error) {
-    return error instanceof Error && error.message.includes("404");
-}
-// ── Schema transform ─────────────────────────────────────────────
-function transformProperties(props) {
-    const out = {};
-    for (const prop of Object.values(props)) {
-        if (BUILTIN_TYPES.has(prop.type)) {
-            continue;
-        }
-        const key = deriveKey(prop.name);
-        if (key) {
-            out[key] = { name: prop.name, type: prop.type };
-        }
-    }
-    return out;
-}
-function fetchDataSource(dataSourceId, quiet) {
-    const id = formatUuid(dataSourceId);
-    if (!quiet) {
-        console.log(`  Fetching data source ${id}…`);
-    }
-    const ds = ntnApi(`/v1/data_sources/${id}`);
-    if (!ds.properties || Object.keys(ds.properties).length === 0) {
-        throw new Error(`Data source ${id} has no properties.`);
-    }
-    return {
-        dataSourceId: id,
-        name: plainText(ds.title),
-        properties: transformProperties(ds.properties),
-    };
-}
-/**
- * Pull schema from a database or data source ID. Tries `/v1/databases/<id>`
- * first (most common entry point); falls back to `/v1/data_sources/<id>` if
- * that 404s. ID-type classification (block / view / database / wrong-workspace)
- * happens upstream in `init.ts` — by the time we get here, the ID is expected
- * to point at a database or data source.
- */
-function fetchSchema(id, quiet) {
-    const uuid = formatUuid(id);
-    let dbError;
-    try {
-        if (!quiet) {
-            console.log(`  Fetching database ${uuid}…`);
-        }
-        const db = ntnApi(`/v1/databases/${uuid}`);
-        if (db.object === "database") {
-            if (!db.data_sources?.length) {
-                throw new Error(`Database ${uuid} has no data sources. Confirm you're logged in to the right workspace with \`${loginHintCommand()}\`.`);
-            }
-            return fetchDataSource(db.data_sources[0].id, quiet);
-        }
-    }
-    catch (error) {
-        if (!is404(error)) {
-            throw error;
-        }
-        dbError = error;
-    }
-    try {
-        return fetchDataSource(uuid, quiet);
-    }
-    catch (error) {
-        if (!is404(error)) {
-            throw error;
-        }
-    }
-    throw new Error(dbError instanceof Error
-        ? `${uuid} isn't a database or data source. Confirm you're logged in to the right workspace with \`${loginHintCommand()}\`.`
-        : `${uuid} isn't a database or data source.`);
-}
-export function pullManifest(options) {
-    const { idOrUrl, key = "default", out = MANIFEST_FILENAME, dryRun = false, quiet = false, } = options;
-    const outPath = resolvePath(process.cwd(), out);
-    const id = extractId(idOrUrl);
-    if (quiet) {
-        console.log("\nPulling data source schema…");
-    }
-    else {
-        console.log(`\nResolving ${idOrUrl}…\n`);
-    }
-    const result = fetchSchema(id, quiet);
-    const entry = {
-        name: result.name,
-        properties: result.properties,
-    };
-    // Read existing manifest or start fresh. The entry for `key` is fully
-    // replaced so stale properties are automatically removed.
-    let manifest;
-    if (existsSync(outPath)) {
-        try {
-            const existing = JSON.parse(readFileSync(outPath, "utf-8"));
-            manifest = { version: 1, dataSources: existing.dataSources ?? {} };
-        }
-        catch {
-            manifest = { version: 1, dataSources: {} };
-        }
-    }
-    else {
-        manifest = { version: 1, dataSources: {} };
-    }
-    manifest.dataSources[key] = entry;
-    const json = JSON.stringify(manifest, null, "\t") + "\n";
-    if (dryRun) {
-        console.log(json);
-        return;
-    }
-    writeFileSync(outPath, json);
-    // Stash the resolved data-source ID in .notion/target.json so `connect`
-    // can wire the block without the user re-typing it. Don't touch block_id
-    // or property_ids_by_key — init seeds block_id at scaffold time, and
-    // `connect` fills in property_ids_by_key.
-    const existingTarget = readTarget();
-    const existingEntry = existingTarget?.data_sources[key];
-    const merged = mergeTarget(existingTarget, {
-        data_sources: {
-            [key]: {
-                data_source_id: result.dataSourceId,
-                property_ids_by_key: existingEntry?.property_ids_by_key ?? {},
-            },
-        },
-    });
-    writeTarget(merged);
-    const count = Object.keys(result.properties).length;
-    if (quiet) {
-        console.log(`Found database "${result.name}" (${count} properties)`);
-        return;
-    }
-    console.log(`\n✓ Updated ${out} (key: "${key}")\n`);
-    console.log(`  → recorded data_source_id in .notion/target.json (${key})`);
-    console.log(`  ${count} properties from "${result.name}":`);
-    for (const [k, p] of Object.entries(result.properties)) {
-        console.log(`    ${k}: ${p.name} (${p.type})`);
-    }
-    console.log("");
-}

package/bin/cli/target.js

@@ -1,95 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, resolve as resolvePath } from "node:path";
-export const TARGET_PATH = ".notion/target.json";
-function defaultTarget() {
-    return { env: "production", block_id: [], data_sources: {} };
-}
-export function resolveTargetPath(cwd = process.cwd()) {
-    return resolvePath(cwd, TARGET_PATH);
-}
-export function readTarget(cwd = process.cwd()) {
-    const path = resolveTargetPath(cwd);
-    if (!existsSync(path)) {
-        return null;
-    }
-    let raw;
-    try {
-        raw = readFileSync(path, "utf-8");
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Error: failed to read ${TARGET_PATH}: ${message}\n  Check file permissions.`);
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch {
-        throw new Error(`Error: ${TARGET_PATH} contains invalid JSON.\n  Fix the syntax or delete the file to regenerate it with 'ncblock connect'.`);
-    }
-    return normalizeTarget(parsed);
-}
-export function writeTarget(config, cwd = process.cwd()) {
-    const path = resolveTargetPath(cwd);
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, JSON.stringify(config, null, "\t") + "\n");
-}
-function normalizeTarget(value) {
-    if (!isRecord(value)) {
-        throw new Error(`Error: ${TARGET_PATH} must be a JSON object.\n  Delete the file to regenerate it with 'ncblock connect'.`);
-    }
-    const env = typeof value.env === "string" ? value.env : "production";
-    const block_id = [];
-    if (Array.isArray(value.block_id)) {
-        for (const entry of value.block_id) {
-            if (typeof entry === "string" && entry.length > 0) {
-                block_id.push(entry);
-            }
-        }
-    }
-    else if (typeof value.block_id === "string" && value.block_id.length > 0) {
-        block_id.push(value.block_id);
-    }
-    const data_sources = {};
-    if (isRecord(value.data_sources)) {
-        for (const [key, ds] of Object.entries(value.data_sources)) {
-            if (!isRecord(ds) || typeof ds.data_source_id !== "string") {
-                continue;
-            }
-            const property_ids_by_key = {};
-            if (isRecord(ds.property_ids_by_key)) {
-                for (const [k, v] of Object.entries(ds.property_ids_by_key)) {
-                    if (typeof v === "string") {
-                        property_ids_by_key[k] = v;
-                    }
-                }
-            }
-            data_sources[key] = {
-                data_source_id: ds.data_source_id,
-                property_ids_by_key,
-            };
-        }
-    }
-    return { env, block_id, data_sources };
-}
-/**
- * Merge a new partial target into the existing one. Block IDs from `incoming`
- * are appended (de-duplicated). Data source bindings replace any existing
- * binding for matching keys; unrelated keys are preserved.
- */
-export function mergeTarget(existing, incoming) {
-    const base = existing ?? defaultTarget();
-    const env = incoming.env ?? base.env;
-    const blockIds = new Set(base.block_id);
-    for (const id of incoming.block_id ?? []) {
-        blockIds.add(id);
-    }
-    const data_sources = {
-        ...base.data_sources,
-        ...(incoming.data_sources ?? {}),
-    };
-    return { env, block_id: [...blockIds], data_sources };
-}
-function isRecord(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}