@eightstate/escli 0.5.0 → 0.7.0

package/dist/commands/notion/db/create.js

@@ -0,0 +1,555 @@
+import { readFile } from 'node:fs/promises';
+import { Args, Flags } from '@oclif/core';
+import { ErrorCode } from '@eightstate/contracts/errors';
+import { ExitCodes } from '@eightstate/contracts/exit-codes';
+import { BaseCommand } from '../../../base-command.js';
+import { EscliError } from '../../../lib/escli-error.js';
+import { writeStdout, writeStderr } from '../../../io/io.js';
+import { renderKv } from '../../../io/render-kv.js';
+import { renderTable } from '../../../io/render-table.js';
+import { NOTION_VERSION, proxy } from '../../../services/notion.js';
+import { hasManifestFlag } from '../../../lib/notion/manifest-pass.js';
+export default class NotionDbCreate extends BaseCommand {
+    static errors = [
+        ErrorCode.UsageRequired,
+        ErrorCode.UsageInvalid,
+        ErrorCode.ValidationFailed,
+        ErrorCode.JsonInvalid,
+        ErrorCode.FileNotFound,
+        ErrorCode.FileReadFailed,
+        ErrorCode.AuthRequired,
+        ErrorCode.NotionUnauthorized,
+        ErrorCode.NotionRestricted,
+        ErrorCode.NotionNotFound,
+        ErrorCode.NotionRateLimited,
+        ErrorCode.NotionValidation,
+        ErrorCode.NotionConflict,
+        ErrorCode.NotionTimeoutUncertain,
+        ErrorCode.NotionEnrollmentRequired,
+        ErrorCode.NotionBatchPartial,
+        ErrorCode.GateInvalidResponse,
+        ErrorCode.NetworkError,
+        ErrorCode.NetworkTimeout,
+        ErrorCode.ServiceUnavailable,
+        ErrorCode.ApiError,
+    ];
+    static summary = 'Create a Notion database and initial data source';
+    static description = 'Create a database container under a parent, create its initial data source schema, and optionally request initial views.';
+    static examples = [
+        '<%= config.bin %> notion db create "Launch CRM" --parent 24f104cd477e80afbc30000bd28de8f9 --schema crm.schema.json --data-source-name Leads --view table:"All leads"',
+        '<%= config.bin %> notion db create "Launch CRM" --parent 24f104cd477e80afbc30000bd28de8f9 --schema crm.schema.json --dry-run',
+        '<%= config.bin %> --json notion db create "Launch CRM" --parent 24f104cd477e80afbc30000bd28de8f9 --schema crm.schema.json',
+    ];
+    static aliases = ['notion database create', 'n db create', 'n database create'];
+    static flags = {
+        parent: Flags.string({ description: 'Parent page ID, page URL, or wiki database ID.', required: true }),
+        'schema-input': Flags.string({ description: 'Schema JSON path, inline JSON, or - for stdin.', required: true, helpValue: 'schema' }),
+        'data-source-name': Flags.string({ description: 'Initial data source name. Defaults to the database title.' }),
+        view: Flags.string({ description: 'Initial view as <type:name>.', multiple: true }),
+        'view-file': Flags.string({ description: 'JSON file containing richer view specs.' }),
+        raw: Flags.boolean({ description: 'Emit verbatim Notion response body.', default: false }),
+        'dry-run': Flags.boolean({ description: 'Validate inputs and print the create payload without writing to Notion.', default: false }),
+    };
+    static args = {
+        title: Args.string({ description: 'Database title.', required: true }),
+    };
+    static enableJsonFlag = true;
+    static strict = true;
+    async run() {
+        if (hasManifestFlag(this.argv)) {
+            await super.run();
+            return;
+        }
+        normalizeSchemaFlagArgv(this.argv);
+        if (this.argv.includes('--raw')) {
+            await this.execute();
+            return;
+        }
+        await super.run();
+    }
+    async execute() {
+        const { args, flags } = await this.parse(NotionDbCreate);
+        const typedFlags = flags;
+        const schema = await parseSchemaInput(typedFlags['schema-input']);
+        const dataSourceName = typedFlags['data-source-name'] ?? args.title;
+        const views = [...parseViewFlags(typedFlags.view), ...await parseViewFileInput(typedFlags['view-file'])];
+        const request = {
+            parent: typedFlags.parent,
+            title: args.title,
+            initial_data_source: { name: dataSourceName, schema },
+            views,
+        };
+        if (flags['dry-run']) {
+            await maybeDryRunWarning(flags, 'database create');
+            const data = dryRunData('database', request);
+            if (!typedFlags.json) {
+                await writeStdout(`${renderDbCreate(data)}\n`);
+                this.humanOutputHandled = true;
+            }
+            return data;
+        }
+        const result = await proxy('POST', '/v1/databases', { body: request });
+        const payload = await emitRawOrReturn(result, typedFlags.raw);
+        const data = normalizeDbCreateResponse(payload, args.title, typedFlags.parent, dataSourceName);
+        if (!typedFlags.json && !typedFlags.raw) {
+            await writeStdout(`${renderDbCreate(data)}\n`);
+            this.humanOutputHandled = true;
+        }
+        return { ...data, raw: result.raw };
+    }
+}
+export const notionCreateErrors = [
+    ErrorCode.UsageRequired,
+    ErrorCode.UsageInvalid,
+    ErrorCode.ValidationFailed,
+    ErrorCode.JsonInvalid,
+    ErrorCode.FileNotFound,
+    ErrorCode.FileReadFailed,
+    ErrorCode.AuthRequired,
+    ErrorCode.NotionUnauthorized,
+    ErrorCode.NotionRestricted,
+    ErrorCode.NotionNotFound,
+    ErrorCode.NotionRateLimited,
+    ErrorCode.NotionValidation,
+    ErrorCode.NotionConflict,
+    ErrorCode.NotionTimeoutUncertain,
+    ErrorCode.NotionEnrollmentRequired,
+    ErrorCode.NotionBatchPartial,
+    ErrorCode.GateInvalidResponse,
+    ErrorCode.NetworkError,
+    ErrorCode.NetworkTimeout,
+    ErrorCode.ServiceUnavailable,
+    ErrorCode.ApiError,
+];
+const supportedPropertyTypes = new Set([
+    'title',
+    'rich_text',
+    'number',
+    'select',
+    'multi_select',
+    'status',
+    'date',
+    'people',
+    'files',
+    'checkbox',
+    'url',
+    'email',
+    'phone_number',
+    'relation',
+    'rollup',
+    'formula',
+    'created_time',
+    'created_by',
+    'last_edited_time',
+    'last_edited_by',
+    'unique_id',
+    'verification',
+]);
+const viewTypes = new Set(['table', 'board', 'list', 'calendar', 'timeline', 'gallery', 'form', 'chart', 'map']);
+export function normalizeSchemaFlagArgv(argv) {
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === '--schema')
+            argv[index] = '--schema-input';
+        else if (token?.startsWith('--schema='))
+            argv[index] = `--schema-input=${token.slice('--schema='.length)}`;
+    }
+}
+export async function emitRawOrReturn(result, raw) {
+    if (raw) {
+        await writeStdout(`${formatRawBody(result.raw)}\n`);
+        return result.raw;
+    }
+    return result.data;
+}
+export function formatRawBody(value) {
+    if (Array.isArray(value))
+        return value.map((item) => JSON.stringify(stripAuthQueryStrings(item), null, 2)).join('\n');
+    return JSON.stringify(stripAuthQueryStrings(value), null, 2);
+}
+export async function maybeDryRunWarning(flags, kind) {
+    if (!flags.quiet && !flags.json)
+        await writeStderr(`dry-run: no Notion write attempted for ${kind}\n`);
+}
+export async function parseJsonInput(value, label) {
+    const input = value === '-' ? await readStdin() : looksLikeJson(value) ? value : await readFileInput(value, label);
+    try {
+        return JSON.parse(input);
+    }
+    catch (error) {
+        throw new EscliError(`${label} JSON is invalid: ${error instanceof Error ? error.message : String(error)}`, {
+            code: ErrorCode.JsonInvalid,
+            exitCode: ExitCodes.Usage,
+        });
+    }
+}
+export async function parseSchemaInput(value) {
+    const schema = await parseJsonInput(value, 'schema');
+    validateSchema(schema);
+    return schema;
+}
+export async function parseOptionalJsonInput(value, label) {
+    return value === undefined ? undefined : parseJsonInput(value, label);
+}
+export async function parseViewFileInput(value) {
+    if (!value)
+        return [];
+    const parsed = await parseJsonInput(value, 'view-file');
+    const views = Array.isArray(parsed) ? parsed : [parsed];
+    return views.map((view, index) => parseViewRecord(view, `view-file[${index}]`));
+}
+export function parseViewFlags(values) {
+    return (values ?? []).map((value) => {
+        const separator = value.indexOf(':');
+        if (separator <= 0 || separator === value.length - 1) {
+            throw new EscliError(`view must be <type:name>, got ${value}`, { code: ErrorCode.UsageInvalid, exitCode: ExitCodes.Usage });
+        }
+        const type = value.slice(0, separator);
+        const name = value.slice(separator + 1);
+        assertViewType(type);
+        return { type, name };
+    });
+}
+export function parseViewType(value) {
+    assertViewType(value);
+    return value;
+}
+export function parseSortFlags(values) {
+    const sorts = (values ?? []).map((value) => {
+        const separator = value.lastIndexOf(':');
+        if (separator <= 0 || separator === value.length - 1) {
+            throw new EscliError(`sort must be <property:asc|property:desc>, got ${value}`, { code: ErrorCode.UsageInvalid, exitCode: ExitCodes.Usage });
+        }
+        const property = value.slice(0, separator);
+        const direction = value.slice(separator + 1);
+        if (direction !== 'asc' && direction !== 'desc') {
+            throw new EscliError(`sort direction must be asc or desc, got ${direction}`, { code: ErrorCode.UsageInvalid, exitCode: ExitCodes.Usage });
+        }
+        return { property, direction: direction === 'asc' ? 'ascending' : 'descending' };
+    });
+    return sorts.length > 0 ? sorts : undefined;
+}
+export function parsePosition(value) {
+    if (!value)
+        return undefined;
+    if (value === 'start' || value === 'end')
+        return value;
+    if (value.startsWith('after:') && value.length > 'after:'.length)
+        return { after_view_id: value.slice('after:'.length) };
+    throw new EscliError(`position must be start, end, or after:<view_id>, got ${value}`, { code: ErrorCode.UsageInvalid, exitCode: ExitCodes.Usage });
+}
+export function viewLocation(flags) {
+    const provided = [flags['in-db'], flags['in-dashboard'], flags['linked-on']].filter(Boolean);
+    if (provided.length !== 1) {
+        throw new EscliError('choose exactly one view location: --in-db, --in-dashboard, or --linked-on', { code: ErrorCode.UsageInvalid, exitCode: ExitCodes.Usage });
+    }
+    if (flags['in-db'])
+        return { database_id: flags['in-db'] };
+    if (flags['in-dashboard'])
+        return { dashboard_view_id: flags['in-dashboard'] };
+    return { page_id: flags['linked-on'] };
+}
+export function renderDbCreate(data) {
+    if (data.created === 'dry_run')
+        return renderDryRun(data.request);
+    const database = data.database;
+    const dataSource = data.data_source;
+    const rows = [
+        ['created', data.created],
+        ['database_id', database?.id],
+        ['title', database?.title],
+    ];
+    if (database?.parent_page_id)
+        rows.push(['parent_page_id', database.parent_page_id]);
+    else if (database?.parent_database_id)
+        rows.push(['parent_database_id', database.parent_database_id]);
+    else if (database?.parent)
+        rows.push(['parent', database.parent]);
+    rows.push(['data_source_id', dataSource?.id], ['data_source', dataSource?.name], ['properties', dataSource?.property_count ?? dataSource?.properties.length ?? 0]);
+    const sections = [renderKv(rows)];
+    if (dataSource?.properties.length)
+        sections.push(renderProperties(dataSource.properties));
+    if (data.views.length)
+        sections.push(renderViews(data.views));
+    sections.push(renderKv([['next', data.next]]));
+    if (data.warning)
+        sections.push(renderKv([['warning', data.warning]]));
+    return sections.join('\n\n');
+}
+export function renderDsCreate(data) {
+    if (data.created === 'dry_run')
+        return renderDryRun(data.request);
+    const dataSource = data.data_source;
+    const sections = [renderKv([
+            ['created', data.created],
+            ['database_id', data.database_id],
+            ['data_source_id', dataSource?.id],
+            ['name', dataSource?.name],
+            ['properties', dataSource?.property_count ?? dataSource?.properties.length ?? 0],
+        ])];
+    if (dataSource?.properties.length)
+        sections.push(renderProperties(dataSource.properties));
+    if (data.views.length)
+        sections.push(renderViews(data.views));
+    sections.push(renderKv([['next', data.next]]));
+    return sections.join('\n\n');
+}
+export function renderViewCreate(data) {
+    if (data.created === 'dry_run')
+        return renderDryRun(data.request);
+    const view = data.view;
+    return renderKv([
+        ['created', data.created],
+        ['view_id', view?.id],
+        ['name', view?.name],
+        ['type', view?.type],
+        ['data_source_id', view?.data_source_id],
+        ['location', view ? renderLocation(view.location) : undefined],
+        ['filter', data.query_shape.filter],
+        ['sorts', data.query_shape.sorts.join(', ')],
+        ['next', data.next],
+    ]);
+}
+export function normalizeDbCreateResponse(value, title, parent, dataSourceName) {
+    const root = recordValue(value);
+    if (isDbCreateData(root))
+        return root;
+    const dataSource = firstRecord(root?.data_sources) ?? findRawDataSource(value);
+    const databaseId = stringValue(root?.id) ?? stringValue(recordValue(recordValue(dataSource)?.parent)?.database_id) ?? '';
+    const dataSourceId = stringValue(recordValue(dataSource)?.id) ?? '';
+    return {
+        created: 'database',
+        database: {
+            id: databaseId,
+            title: extractTitle(root?.title) ?? title,
+            ...parentField(root?.parent, parent),
+        },
+        data_source: {
+            id: dataSourceId,
+            name: stringValue(recordValue(dataSource)?.name) ?? dataSourceName,
+            properties: extractProperties(recordValue(dataSource)?.properties ?? root?.properties),
+            property_count: extractProperties(recordValue(dataSource)?.properties ?? root?.properties).length,
+        },
+        views: extractViews(value),
+        next: `escli notion page create --data-source ${dataSourceId} --props <file>`,
+        warning: databaseId && dataSourceId && databaseId !== dataSourceId ? 'database_id and data_source_id are different; rows use data_source_id.' : undefined,
+    };
+}
+export function normalizeDsCreateResponse(value, databaseId, name) {
+    const root = recordValue(value);
+    if (isDsCreateData(root))
+        return root;
+    const dataSource = root?.object === 'data_source' ? root : findRawDataSource(value);
+    const dataSourceId = stringValue(dataSource?.id) ?? '';
+    const properties = extractProperties(dataSource?.properties);
+    return {
+        created: 'data_source',
+        database_id: stringValue(recordValue(dataSource?.parent)?.database_id) ?? databaseId,
+        data_source: { id: dataSourceId, name: stringValue(dataSource?.name) ?? name, properties, property_count: properties.length },
+        views: extractViews(value),
+        next: `escli notion page create --data-source ${dataSourceId} --props <file>`,
+    };
+}
+export function normalizeViewCreateResponse(value, fallback) {
+    const root = recordValue(value);
+    if (isViewCreateData(root))
+        return root;
+    const view = findRawView(value) ?? root;
+    const viewId = stringValue(view?.id) ?? '';
+    const sorts = extractSortLabels(view?.sorts) ?? (fallback.sorts ?? []).map((sort) => `${sort.property} ${sort.direction === 'ascending' ? 'asc' : 'desc'}`);
+    return {
+        created: 'view',
+        view: {
+            id: viewId,
+            name: stringValue(view?.name) ?? fallback.name,
+            type: stringValue(view?.type) ?? fallback.type,
+            data_source_id: stringValue(view?.data_source_id) ?? fallback.data_source_id,
+            location: locationFromRaw(view) ?? fallback.location,
+        },
+        query_shape: { filter: summarizeFilter(view?.filter ?? fallback.filter), sorts },
+        next: `escli notion view query ${viewId}`,
+    };
+}
+export function dryRunData(kind, request) {
+    return { created: 'dry_run', views: [], next: `dry-run: rerun without --dry-run to create ${kind}`, request };
+}
+export function notionMetaEnvelope(data) {
+    return { ...data, next_cursor: null, notion_version: NOTION_VERSION };
+}
+function renderProperties(properties) {
+    return renderTable({ header: ['property', 'id', 'type'], rows: properties.map((property) => [property.name, property.id, property.type]) });
+}
+function renderViews(views) {
+    return renderTable({ header: ['view', 'id', 'type'], rows: views.map((view) => [view.name, view.id, view.type]) });
+}
+function renderDryRun(request) {
+    return `${renderKv([['created', 'dry_run'], ['notion_version', NOTION_VERSION], ['write_attempted', false]])}\n\n${JSON.stringify(request, null, 2)}`;
+}
+function renderLocation(location) {
+    if ('database_id' in location)
+        return `database ${location.database_id}`;
+    if ('dashboard_view_id' in location)
+        return `dashboard ${location.dashboard_view_id}`;
+    return `page ${location.page_id}`;
+}
+function validateSchema(schema) {
+    const properties = recordValue(recordValue(schema)?.properties ?? schema);
+    if (!properties)
+        throw new EscliError('schema must be a JSON object with properties', { code: ErrorCode.UsageInvalid, exitCode: ExitCodes.Usage });
+    for (const [name, property] of Object.entries(properties)) {
+        const type = stringValue(recordValue(property)?.type) ?? Object.keys(recordValue(property) ?? {})[0];
+        if (!type || !supportedPropertyTypes.has(type)) {
+            throw new EscliError(`unsupported schema property type for ${name}: ${type ?? 'missing'}`, { code: ErrorCode.UsageInvalid, exitCode: ExitCodes.Usage });
+        }
+    }
+}
+function parseViewRecord(value, label) {
+    const record = recordValue(value);
+    if (!record)
+        throw new EscliError(`${label} must be an object`, { code: ErrorCode.UsageInvalid, exitCode: ExitCodes.Usage });
+    const type = stringValue(record.type);
+    const name = stringValue(record.name);
+    if (!type || !name)
+        throw new EscliError(`${label} must include type and name`, { code: ErrorCode.UsageInvalid, exitCode: ExitCodes.Usage });
+    assertViewType(type);
+    return { ...record, type, name };
+}
+function assertViewType(value) {
+    if (!viewTypes.has(value))
+        throw new EscliError(`unsupported view type: ${value}`, { code: ErrorCode.UsageInvalid, exitCode: ExitCodes.Usage });
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin)
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    return Buffer.concat(chunks).toString('utf8');
+}
+async function readFileInput(path, label) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch (error) {
+        throw new EscliError(`${label} file not found or unreadable: ${path}`, { code: ErrorCode.FileReadFailed, exitCode: ExitCodes.NotFound, details: error instanceof Error ? error.message : error });
+    }
+}
+function looksLikeJson(value) {
+    const trimmed = value.trimStart();
+    return trimmed.startsWith('{') || trimmed.startsWith('[');
+}
+function stripAuthQueryStrings(value) {
+    if (Array.isArray(value))
+        return value.map(stripAuthQueryStrings);
+    const record = recordValue(value);
+    if (!record)
+        return value;
+    return Object.fromEntries(Object.entries(record).map(([key, nested]) => [key, key === 'upload_url' || key === 'complete_url' ? stripQueryString(nested) : stripAuthQueryStrings(nested)]));
+}
+function stripQueryString(value) {
+    return typeof value === 'string' ? value.replace(/\?.*$/u, '') : value;
+}
+function isDbCreateData(value) {
+    return value?.created === 'database' && Boolean(recordValue(value.database));
+}
+function isDsCreateData(value) {
+    return value?.created === 'data_source' && typeof value.database_id === 'string';
+}
+function isViewCreateData(value) {
+    return value?.created === 'view' && Boolean(recordValue(value.view));
+}
+function extractProperties(value) {
+    const properties = recordValue(value);
+    if (!properties)
+        return [];
+    return Object.entries(properties).map(([name, property]) => {
+        const record = recordValue(property) ?? {};
+        return { name: stringValue(record.name) ?? name, id: stringValue(record.id) ?? '', type: stringValue(record.type) ?? '' };
+    });
+}
+function extractViews(value) {
+    const values = Array.isArray(value) ? value : Array.isArray(recordValue(value)?.views) ? recordValue(value)?.views : [];
+    return values.map(recordValue).filter((view) => view?.object === 'view' || (typeof view?.id === 'string' && typeof view?.type === 'string' && typeof view?.name === 'string')).map((view) => ({ id: stringValue(view?.id) ?? '', name: stringValue(view?.name) ?? '', type: stringValue(view?.type) ?? '' }));
+}
+function findRawDataSource(value) {
+    const values = Array.isArray(value) ? value : [];
+    return values.map(recordValue).find((record) => record?.object === 'data_source');
+}
+function findRawView(value) {
+    const values = Array.isArray(value) ? value : [];
+    return values.map(recordValue).find((record) => record?.object === 'view');
+}
+function locationFromRaw(value) {
+    const databaseId = stringValue(value?.database_id);
+    if (databaseId)
+        return { database_id: databaseId };
+    const dashboardId = stringValue(value?.dashboard_view_id);
+    if (dashboardId)
+        return { dashboard_view_id: dashboardId };
+    const pageId = stringValue(value?.page_id);
+    if (pageId)
+        return { page_id: pageId };
+    return undefined;
+}
+function parentField(parent, fallback) {
+    const record = recordValue(parent);
+    const pageId = stringValue(record?.page_id);
+    if (pageId)
+        return { parent_page_id: pageId };
+    const databaseId = stringValue(record?.database_id);
+    if (databaseId)
+        return { parent_database_id: databaseId };
+    return { parent_page_id: fallback };
+}
+function extractTitle(value) {
+    if (typeof value === 'string')
+        return value;
+    if (Array.isArray(value))
+        return value.map((part) => stringValue(recordValue(part)?.plain_text) ?? stringValue(recordValue(recordValue(part)?.text)?.content) ?? '').join('') || undefined;
+    return undefined;
+}
+function extractSortLabels(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    return value.map((sort) => {
+        const record = recordValue(sort) ?? {};
+        const property = stringValue(record.property) ?? '';
+        const direction = stringValue(record.direction) === 'ascending' ? 'asc' : stringValue(record.direction) === 'descending' ? 'desc' : stringValue(record.direction) ?? '';
+        return `${property} ${direction}`.trim();
+    }).filter(Boolean);
+}
+function summarizeFilter(value) {
+    if (!value)
+        return undefined;
+    const count = countRules(value);
+    const firstProperty = firstFilterProperty(value);
+    return firstProperty ? `${count} ${firstProperty} rule${count === 1 ? '' : 's'}` : `${count} rule${count === 1 ? '' : 's'}`;
+}
+function countRules(value) {
+    if (Array.isArray(value))
+        return value.reduce((sum, item) => sum + countRules(item), 0);
+    const record = recordValue(value);
+    if (!record)
+        return 0;
+    if (Array.isArray(record.and))
+        return countRules(record.and);
+    if (Array.isArray(record.or))
+        return countRules(record.or);
+    return stringValue(record.property) ? 1 : Object.values(record).reduce((sum, item) => sum + countRules(item), 0);
+}
+function firstFilterProperty(value) {
+    if (Array.isArray(value))
+        return value.map(firstFilterProperty).find(Boolean);
+    const record = recordValue(value);
+    if (!record)
+        return undefined;
+    return stringValue(record.property) ?? firstFilterProperty(record.and) ?? firstFilterProperty(record.or);
+}
+function firstRecord(value) {
+    return Array.isArray(value) ? recordValue(value[0]) : undefined;
+}
+function recordValue(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+function stringValue(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+//# sourceMappingURL=create.js.map