@eightstate/escli 0.5.0 → 0.7.0

package/dist/lib/notion/db-row/common.js

@@ -0,0 +1,367 @@
+import { readFile } from 'node:fs/promises';
+import { Errors } from '@oclif/core';
+import { ErrorCode } from '@eightstate/contracts/errors';
+import { ExitCodes } from '@eightstate/contracts/exit-codes';
+import { EscliError } from '../../escli-error.js';
+import { NOTION_VERSION } from '../../../services/notion.js';
+import { writeStdout, writeStderr } from '../../../io/io.js';
+import { renderKv } from '../../../io/render-kv.js';
+import { renderTable } from '../../../io/render-table.js';
+export const dbWriteErrors = [
+    ErrorCode.UsageInvalid,
+    ErrorCode.UsageRequired,
+    ErrorCode.ValidationFailed,
+    ErrorCode.JsonInvalid,
+    ErrorCode.FileNotFound,
+    ErrorCode.FileReadFailed,
+    ErrorCode.AuthRequired,
+    ErrorCode.NotionUnauthorized,
+    ErrorCode.NotionEnrollmentRequired,
+    ErrorCode.NotionRestricted,
+    ErrorCode.NotionNotFound,
+    ErrorCode.NotionRateLimited,
+    ErrorCode.NotionValidation,
+    ErrorCode.NotionConflict,
+    ErrorCode.NotionTimeoutUncertain,
+    ErrorCode.NotionBatchPartial,
+    ErrorCode.GateInvalidResponse,
+    ErrorCode.GateCredentialUnavailable,
+    ErrorCode.ApiError,
+    ErrorCode.NetworkError,
+    ErrorCode.NetworkTimeout,
+    ErrorCode.ServiceUnavailable,
+];
+export function parseJsonObject(value, label) {
+    try {
+        const parsed = JSON.parse(value);
+        if (!isRecord(parsed))
+            throw new Error(`${label} must be a JSON object`);
+        return parsed;
+    }
+    catch (error) {
+        throw new EscliError(error instanceof Error ? error.message : `invalid ${label}`, {
+            code: ErrorCode.JsonInvalid,
+            exitCode: ExitCodes.Usage,
+        });
+    }
+}
+export async function readJsonObjectInput(value, label) {
+    if (!value) {
+        throw new EscliError(`${label} is required`, { code: ErrorCode.UsageRequired, exitCode: ExitCodes.Usage });
+    }
+    if (value === '-')
+        return parseJsonObject(await readStdin(), label);
+    if (value.startsWith('@'))
+        return parseJsonObject(await readTextFile(value.slice(1)), label);
+    return parseJsonObject(value, label);
+}
+export async function readIdsFileRows(path) {
+    const content = path === '-' ? await readStdin() : await readTextFile(path);
+    return content.split(/\r?\n/u).map((line) => line.trim()).filter(Boolean).map((line, index) => {
+        const row = parseJsonObject(line, `ids-file line ${index + 1}`);
+        if (typeof row.id !== 'string' || row.id.length === 0) {
+            throw new EscliError(`ids-file line ${index + 1} requires string id`, { code: ErrorCode.ValidationFailed, exitCode: ExitCodes.Usage });
+        }
+        if (!isRecord(row.properties)) {
+            throw new EscliError(`ids-file line ${index + 1} requires properties object`, { code: ErrorCode.ValidationFailed, exitCode: ExitCodes.Usage });
+        }
+        return { id: row.id, properties: row.properties };
+    });
+}
+export function rawOutput(result) {
+    if (isRecord(result) && 'raw' in result)
+        return result.raw;
+    return result;
+}
+export function normalizeCreate(result, written) {
+    const page = pageRecord(result.data);
+    return {
+        action: 'created',
+        page: { id: stringValue(page.id), title: extractTitle(page), url: stringValue(page.url) },
+        parent: extractParent(page),
+        written: normalizeWritten(written),
+        bot: extractBot(page),
+        last_edited_time: stringValue(page.last_edited_time),
+        raw: result.raw,
+        meta: { next: null, notion_version: NOTION_VERSION },
+    };
+}
+export function normalizeUpdate(result, beforeRaw, requested) {
+    const before = pageRecord(beforeRaw);
+    const after = pageRecord(result.data);
+    const changes = buildChanges(before, after, requested);
+    const changedNames = new Set(changes.map((change) => change.property));
+    return {
+        action: 'updated',
+        page: { id: stringValue(after.id), title: extractTitle(after), url: stringValue(after.url) },
+        changes,
+        unchanged: Object.keys(requested).filter((name) => !changedNames.has(name)),
+        last_edited_time: stringValue(after.last_edited_time),
+        bot: extractBot(after),
+        raw: { before: beforeRaw, after: result.raw },
+        meta: { next: null, notion_version: NOTION_VERSION },
+    };
+}
+export function renderCreate(data) {
+    return renderKv([
+        ['action', data.action],
+        ['page_id', data.page.id],
+        ['title', data.page.title],
+        ['url', data.page.url],
+        ['data_source_id', data.parent.data_source_id],
+        ['database_id', data.parent.database_id ?? ''],
+        ['written', formatPropertyList(data.written)],
+        ['bot', data.bot],
+        ['last_edited_time', data.last_edited_time],
+    ]);
+}
+export function renderUpdate(data) {
+    if ('rows' in data)
+        return renderBatch(data);
+    const lines = [renderKv([
+            ['action', data.action],
+            ['page_id', data.page.id],
+            ['title', data.page.title],
+            ['url', data.page.url],
+        ])];
+    lines.push('changes:');
+    if (data.changes.length === 0)
+        lines.push('  none');
+    for (const change of data.changes)
+        lines.push(`  ${change.property}: ${formatScalar(change.from)} → ${formatScalar(change.to)}${change.cleared ? ' (cleared)' : ''}`);
+    lines.push(`unchanged: ${data.unchanged.length > 0 ? data.unchanged.join(', ') : 'none'}`);
+    lines.push(renderKv([
+        ['bot', data.bot],
+        ['last_edited_time', data.last_edited_time],
+    ]));
+    return lines.join('\n');
+}
+export function renderBatch(data) {
+    return [
+        `action: ${data.action}`,
+        `rows: ${data.rows_count} ok=${data.ok_count} err=${data.err_count}`,
+        renderTable({
+            header: ['#', 'id', 'status', 'reason'],
+            rows: data.rows.map((row) => [row.index, abbreviateId(row.id), row.status, row.reason]),
+        }),
+        `bot: ${data.bot}`,
+    ].join('\n');
+}
+export function stripCommandFields(data) {
+    const rest = { ...data };
+    delete rest.raw;
+    delete rest.meta;
+    return rest;
+}
+export async function emitSuccessEnvelope(command, version, data, durationMs) {
+    await writeStdout(`${JSON.stringify({ ok: true, data, error: null, meta: notionEnvelopeMeta(command, version, durationMs) })}\n`);
+}
+export async function emitErrorEnvelope(command, version, error, durationMs, json) {
+    process.exitCode = error.exitCode;
+    if (json) {
+        await writeStdout(`${JSON.stringify({
+            ok: false,
+            data: null,
+            error: {
+                code: error.code,
+                message: error.message,
+                remediation: error.remediation,
+                details: error.details,
+                cause_code: error.causeCode,
+            },
+            meta: notionEnvelopeMeta(command, version, durationMs),
+        })}\n`);
+        return;
+    }
+    await writeStderr(`${error.message}\n`);
+}
+export function toEscliError(error) {
+    if (error instanceof EscliError)
+        return error;
+    if (error instanceof Errors.CLIError) {
+        return new EscliError(cleanOclifMessage(error.message), { code: classifyOclifUsageError(error), exitCode: ExitCodes.Usage, details: { oclif_exit: error.oclif?.exit } });
+    }
+    if (error instanceof Error)
+        return new EscliError(error.message, { code: ErrorCode.Internal });
+    return new EscliError('unknown error', { code: ErrorCode.Unknown, details: error });
+}
+function classifyOclifUsageError(error) {
+    const name = error.constructor.name;
+    const message = error.message;
+    if (name === 'NonExistentFlagsError' || message.startsWith('Nonexistent flag') || message.startsWith('Unexpected flag'))
+        return ErrorCode.UsageUnknownFlag;
+    if (name === 'RequiredArgsError' || message.startsWith('Missing ') || message.includes('expects a value'))
+        return ErrorCode.UsageRequired;
+    return ErrorCode.UsageInvalid;
+}
+function cleanOclifMessage(message) {
+    return message.replace(/\nSee more help with --help$/u, '');
+}
+export function notionEnvelopeMeta(command, version, durationMs) {
+    return {
+        schema_version: '1',
+        escli_version: version,
+        command,
+        warnings: [],
+        duration_ms: durationMs,
+        next: null,
+        notion_version: NOTION_VERSION,
+    };
+}
+export function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function pageRecord(value) {
+    return isRecord(value) ? value : {};
+}
+function extractParent(page) {
+    const parent = isRecord(page.parent) ? page.parent : {};
+    return { data_source_id: stringValue(parent.data_source_id), database_id: nullableString(parent.database_id) };
+}
+function extractBot(page) {
+    const lastEditedBy = isRecord(page.last_edited_by) ? page.last_edited_by : {};
+    const createdBy = isRecord(page.created_by) ? page.created_by : {};
+    return stringValue(lastEditedBy.name) || stringValue(createdBy.name) || stringValue(lastEditedBy.id) || stringValue(createdBy.id);
+}
+function extractTitle(page) {
+    const title = stringValue(page.title);
+    if (title)
+        return title;
+    const properties = isRecord(page.properties) ? page.properties : {};
+    for (const property of Object.values(properties)) {
+        if (!isRecord(property) || property.type !== 'title' || !Array.isArray(property.title))
+            continue;
+        const plain = property.title.map((item) => isRecord(item) ? stringValue(item.plain_text) : '').join('');
+        if (plain)
+            return plain;
+    }
+    return '';
+}
+function buildChanges(before, after, requested) {
+    const beforeProps = isRecord(before.properties) ? before.properties : {};
+    const afterProps = isRecord(after.properties) ? after.properties : {};
+    const changes = [];
+    for (const [name, requestedValue] of Object.entries(requested)) {
+        const beforeProperty = beforeProps[name];
+        const afterProperty = afterProps[name];
+        const type = propertyType(afterProperty) ?? propertyType(beforeProperty);
+        const from = simplifyProperty(beforeProperty);
+        const to = simplifyProperty(afterProperty, requestedValue);
+        if (!deepEqual(from, to))
+            changes.push({ property: name, type, from, to, ...(to === null ? { cleared: true } : {}) });
+    }
+    return changes;
+}
+function propertyType(value) {
+    return isRecord(value) && typeof value.type === 'string' ? value.type : undefined;
+}
+function simplifyProperty(property, fallback) {
+    if (!isRecord(property))
+        return fallback ?? null;
+    const type = propertyType(property);
+    switch (type) {
+        case 'title':
+            return richTextPlain(property.title);
+        case 'rich_text':
+            return richTextPlain(property.rich_text);
+        case 'select':
+        case 'status':
+            return isRecord(property[type]) ? stringValue(property[type].name) : null;
+        case 'multi_select':
+            return Array.isArray(property.multi_select) ? property.multi_select.map((item) => isRecord(item) ? stringValue(item.name) : '').filter(Boolean) : [];
+        case 'date':
+            return isRecord(property.date) ? stringValue(property.date.start) : null;
+        case 'people':
+            return Array.isArray(property.people) ? property.people.map((person) => isRecord(person) ? stringValue(person.name) || stringValue(person.id) : '').filter(Boolean) : [];
+        case 'files':
+            return Array.isArray(property.files) ? property.files.map((file) => isRecord(file) ? stringValue(file.name) : '').filter(Boolean) : [];
+        case 'relation':
+            return Array.isArray(property.relation) ? property.relation.map((relation) => isRecord(relation) ? stringValue(relation.id) : '').filter(Boolean) : [];
+        case 'number':
+        case 'checkbox':
+        case 'email':
+        case 'phone_number':
+        case 'url':
+            return property[type];
+        case 'verification':
+            return simplifyVerification(property.verification);
+        default:
+            return fallback ?? property;
+    }
+}
+function richTextPlain(value) {
+    return Array.isArray(value) ? value.map((item) => {
+        if (!isRecord(item))
+            return '';
+        if (typeof item.plain_text === 'string')
+            return item.plain_text;
+        const text = isRecord(item.text) ? item.text : {};
+        return stringValue(text.content);
+    }).join('') : '';
+}
+function simplifyVerification(value) {
+    if (!isRecord(value))
+        return value ?? null;
+    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== null && entry !== undefined));
+}
+function normalizeWritten(properties) {
+    return Object.fromEntries(Object.entries(properties).map(([name, value]) => [name, simplifyInputValue(value)]));
+}
+function simplifyInputValue(value) {
+    if (!isRecord(value))
+        return value;
+    const type = Object.keys(value)[0];
+    if (!type)
+        return value;
+    return simplifyProperty({ type, [type]: value[type] }, value);
+}
+function formatPropertyList(properties) {
+    return Object.entries(properties).map(([name, value]) => `${name}=${formatQuoted(value)}`).join('; ');
+}
+function formatQuoted(value) {
+    if (typeof value === 'string')
+        return `"${value}"`;
+    return formatScalar(value);
+}
+function formatScalar(value) {
+    if (value === null || value === undefined)
+        return 'null';
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean')
+        return String(value);
+    return JSON.stringify(value);
+}
+function abbreviateId(id) {
+    return id.length > 9 ? `${id.slice(0, 8)}…` : id;
+}
+function deepEqual(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+function stringValue(value) {
+    return typeof value === 'string' ? value : '';
+}
+function nullableString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : null;
+}
+async function readTextFile(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch (error) {
+        throw new EscliError(`failed to read ${path}: ${error instanceof Error ? error.message : String(error)}`, {
+            code: ErrorCode.FileReadFailed,
+            exitCode: ExitCodes.Error,
+        });
+    }
+}
+async function readStdin() {
+    return new Promise((resolve, reject) => {
+        let data = '';
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk) => {
+            data += chunk;
+        });
+        process.stdin.on('end', () => resolve(data));
+        process.stdin.on('error', reject);
+    });
+}
+//# sourceMappingURL=common.js.map

package/dist/lib/notion/manifest-pass.js

@@ -0,0 +1,4 @@
+export function hasManifestFlag(argv) {
+    return argv.some((t) => t === '--describe' || t.startsWith('--describe=') || t === '--schema' || t.startsWith('--schema='));
+}
+//# sourceMappingURL=manifest-pass.js.map