@jordancoin/notioncli 1.2.1 → 1.3.1

package/commands/crud.js

@@ -0,0 +1,196 @@
+const fs = require('fs');
+const path = require('path');
+
+module.exports = {
+  register(program, ctx) {
+    const {
+      getNotion,
+      resolveDb,
+      resolvePageId,
+      getDbSchema,
+      buildProperties,
+      jsonOutput,
+      richTextToPlain,
+      propValue,
+      extractDynamicProps,
+      markdownToBlocks,
+      runCommand,
+    } = ctx;
+
+    // ─── add ──────────────────────────────────────────────────────────────────
+    program
+      .command('add <database>')
+      .description('Add a new page to a database (e.g. notion add tasks --name "Ship it" --status "Done")')
+      .option('--prop <key=value...>', 'Property value — repeatable (e.g. --prop "Name=Hello")', (v, prev) => prev.concat([v]), [])
+      .option('--from <file>', 'Import content from a .md file as page body')
+      .allowUnknownOption()
+      .allowExcessArguments()
+      .action(async (db, opts, cmd) => runCommand('Add', async () => {
+        const notion = getNotion();
+        const dbIds = resolveDb(db);
+
+        // Merge --prop flags with dynamic property flags (--name, --status, etc.)
+        const schema = await getDbSchema(dbIds);
+        const knownFlags = ['prop', 'from', 'json', 'workspace', 'w', 'filter', 'limit', 'sort', 'output'];
+        const dynamicProps = extractDynamicProps(process.argv, knownFlags, schema);
+        const allProps = [...(opts.prop || []), ...dynamicProps];
+
+        if (allProps.length === 0) {
+          console.error('No properties provided. Use property flags or --prop:');
+          console.error(`  notion add ${db} --name "My Page" --status "Active"`);
+          console.error(`  notion add ${db} --prop "Name=My Page" --prop "Status=Active"`);
+          const propNames = Object.values(schema).map(s => `--${s.name.toLowerCase().replace(/\s+/g, '-')}`);
+          console.error(`\nAvailable: ${propNames.join(', ')}`);
+          process.exit(1);
+        }
+
+        const properties = await buildProperties(dbIds, allProps);
+        const res = await notion.pages.create({
+          parent: { type: 'data_source_id', data_source_id: dbIds.data_source_id },
+          properties,
+        });
+
+        // If --from file, parse and append blocks
+        if (opts.from) {
+          const filePath = path.resolve(opts.from);
+          if (!fs.existsSync(filePath)) {
+            console.error(`File not found: ${filePath}`);
+            process.exit(1);
+          }
+          const content = fs.readFileSync(filePath, 'utf-8');
+          const ext = path.extname(filePath).toLowerCase();
+
+          let blocks;
+          if (ext === '.md' || ext === '.markdown') {
+            blocks = markdownToBlocks(content);
+          } else {
+            // Treat as plain text
+            blocks = [{ object: 'block', type: 'paragraph', paragraph: { rich_text: [{ type: 'text', text: { content } }] } }];
+          }
+
+          // Notion API limits to 100 blocks per append call
+          for (let i = 0; i < blocks.length; i += 100) {
+            await notion.blocks.children.append({
+              block_id: res.id,
+              children: blocks.slice(i, i + 100),
+            });
+          }
+        }
+
+        if (jsonOutput(cmd, res)) return;
+        console.log(`✅ Created page: ${res.id}`);
+        console.log(`   URL: ${res.url}`);
+        if (opts.from) console.log(`   Content imported from: ${opts.from}`);
+      }));
+
+    // ─── update ────────────────────────────────────────────────────────────────
+    program
+      .command('update <page-or-alias>')
+      .description('Update a page\'s properties by ID or alias + filter (e.g. notion update tasks --filter "Name=Ship it" --status "Done")')
+      .option('--filter <key=value...>', 'Filter to find the page — repeatable for AND (required with alias)', (v, prev) => prev.concat([v]), [])
+      .option('--prop <key=value...>', 'Property value — repeatable', (v, prev) => prev.concat([v]), [])
+      .allowUnknownOption()
+      .allowExcessArguments()
+      .action(async (target, opts, cmd) => runCommand('Update', async () => {
+        const notion = getNotion();
+        const { pageId, dbIds: resolvedDbIds } = await resolvePageId(target, opts.filter);
+        let dbIds = resolvedDbIds;
+        if (!dbIds) {
+          const page = await notion.pages.retrieve({ page_id: pageId });
+          const dsId = page.parent?.data_source_id;
+          if (!dsId) {
+            console.error('Page is not in a database — cannot auto-detect property types.');
+            process.exit(1);
+          }
+          dbIds = { data_source_id: dsId, database_id: page.parent?.database_id || dsId };
+        }
+        // Merge --prop flags with dynamic property flags
+        const schema = await getDbSchema(dbIds);
+        const knownFlags = ['prop', 'filter', 'json', 'workspace', 'w', 'limit', 'sort', 'output'];
+        const dynamicProps = extractDynamicProps(process.argv, knownFlags, schema);
+        const allProps = [...(opts.prop || []), ...dynamicProps];
+
+        if (allProps.length === 0) {
+          console.error('No properties to update. Use property flags or --prop:');
+          console.error(`  notion update ${target} --filter "Name=..." --status "Done"`);
+          process.exit(1);
+        }
+
+        const properties = await buildProperties(dbIds, allProps);
+        const res = await notion.pages.update({ page_id: pageId, properties });
+        if (jsonOutput(cmd, res)) return;
+        console.log(`✅ Updated page: ${res.id}`);
+      }));
+
+    // ─── delete (archive) ──────────────────────────────────────────────────────
+    program
+      .command('delete <page-or-alias>')
+      .description('Delete (archive) a page by ID or alias + filter')
+      .option('--filter <key=value>', 'Filter to find the page (required when using an alias)')
+      .action(async (target, opts, cmd) => runCommand('Delete', async () => {
+        const notion = getNotion();
+        const { pageId } = await resolvePageId(target, opts.filter);
+        const res = await notion.pages.update({ page_id: pageId, archived: true });
+        if (jsonOutput(cmd, res)) return;
+        console.log('🗑️  Archived page: ' + res.id);
+        console.log('   (Restore it from the trash in Notion if needed)');
+      }));
+
+    // ─── get ──────────────────────────────────────────────────────────────────
+    program
+      .command('get <page-or-alias>')
+      .description('Get a page\'s properties by ID or alias + filter')
+      .option('--filter <key=value>', 'Filter to find the page (required when using an alias)')
+      .action(async (target, opts, cmd) => runCommand('Get', async () => {
+        const notion = getNotion();
+        const { pageId } = await resolvePageId(target, opts.filter);
+        const page = await notion.pages.retrieve({ page_id: pageId });
+        if (jsonOutput(cmd, page)) return;
+        console.log(`Page: ${page.id}`);
+        console.log(`URL:  ${page.url}`);
+        console.log(`Created: ${page.created_time}`);
+        console.log(`Updated: ${page.last_edited_time}`);
+        console.log('');
+        console.log('Properties:');
+        for (const [name, prop] of Object.entries(page.properties)) {
+          if (prop.type === 'relation') {
+            const rels = prop.relation || [];
+            if (rels.length === 0) {
+              console.log(`  ${name}: (none)`);
+            } else {
+              // Resolve relation titles
+              const titles = [];
+              for (const rel of rels) {
+                try {
+                  const linked = await notion.pages.retrieve({ page_id: rel.id });
+                  let t = '';
+                  for (const [, p] of Object.entries(linked.properties)) {
+                    if (p.type === 'title') { t = propValue(p); break; }
+                  }
+                  titles.push(t || rel.id.slice(0, 8) + '…');
+                } catch {
+                  titles.push(rel.id.slice(0, 8) + '…');
+                }
+              }
+              console.log(`  ${name}: ${titles.join(', ')}`);
+            }
+          } else if (prop.type === 'rollup') {
+            const r = prop.rollup;
+            if (!r) {
+              console.log(`  ${name}: (empty)`);
+            } else if (r.type === 'number') {
+              console.log(`  ${name}: ${r.number != null ? r.number : '(empty)'}`);
+            } else if (r.type === 'date') {
+              console.log(`  ${name}: ${r.date ? r.date.start : '(empty)'}`);
+            } else if (r.type === 'array' && r.array) {
+              console.log(`  ${name}: ${r.array.map(item => propValue(item)).join(', ')}`);
+            } else {
+              console.log(`  ${name}: ${JSON.stringify(r)}`);
+            }
+          } else {
+            console.log(`  ${name}: ${propValue(prop)}`);
+          }
+        }
+      }));
+  },
+};

package/commands/database.js

@@ -0,0 +1,241 @@
+module.exports = {
+  register(program, ctx) {
+    const {
+      getNotion,
+      resolveDb,
+      loadConfig,
+      saveConfig,
+      getWorkspaceName,
+      jsonOutput,
+      richTextToPlain,
+      propValue,
+      printTable,
+      paginate,
+      runCommand,
+    } = ctx;
+
+    // ─── dbs ────────────────────────────────────────────────────────────────
+    program
+      .command('dbs')
+      .description('List all databases shared with your integration')
+      .action(async (opts, cmd) => runCommand('List databases', async () => {
+        const notion = getNotion();
+        const { results, response } = await paginate(
+          ({ start_cursor, page_size }) => notion.search({
+            filter: { value: 'data_source', property: 'object' },
+            start_cursor,
+            page_size,
+          }),
+          { pageSizeLimit: 100 },
+        );
+        if (jsonOutput(cmd, response)) return;
+        const rows = results.map(db => ({
+          id: db.id,
+          title: richTextToPlain(db.title),
+          url: db.url || '',
+        }));
+        if (rows.length === 0) {
+          console.log('No databases found. Make sure you\'ve shared databases with your integration.');
+          console.log('In Notion: open a database → ••• menu → Connections → Add your integration');
+          return;
+        }
+        printTable(rows, ['id', 'title', 'url']);
+      }));
+
+    // ─── templates ───────────────────────────────────────────────────────────
+    program
+      .command('templates <database>')
+      .description('List page templates available for a database')
+      .action(async (db, opts, cmd) => runCommand('Templates', async () => {
+        const notion = getNotion();
+        const dbIds = resolveDb(db);
+        const res = await notion.dataSources.listTemplates({
+          data_source_id: dbIds.data_source_id,
+        });
+        if (jsonOutput(cmd, res)) return;
+        if (!res.results || res.results.length === 0) {
+          console.log('No templates found for this database.');
+          return;
+        }
+        const rows = res.results.map(t => {
+          let title = '';
+          if (t.properties) {
+            for (const [, prop] of Object.entries(t.properties)) {
+              if (prop.type === 'title') {
+                title = propValue(prop);
+                break;
+              }
+            }
+          }
+          return {
+            id: t.id,
+            title: title || '(untitled)',
+            url: t.url || '',
+          };
+        });
+        printTable(rows, ['id', 'title', 'url']);
+      }));
+
+    // ─── db-create ───────────────────────────────────────────────────────────
+    program
+      .command('db-create <parent-page-id> <title>')
+      .description('Create a new database under a page')
+      .option('--prop <name:type...>', 'Property definition — repeatable (e.g. --prop "Status:select" --prop "Priority:number")', (v, prev) => prev.concat([v]), [])
+      .option('--alias <name>', 'Auto-create an alias for the new database')
+      .action(async (parentPageId, title, opts, cmd) => runCommand('Database create', async () => {
+        const notion = getNotion();
+
+        // Build properties — always include a title property
+        const properties = {};
+        let hasTitleProp = false;
+
+        for (const kv of opts.prop) {
+          const colonIdx = kv.indexOf(':');
+          if (colonIdx === -1) {
+            console.error(`Invalid property format: ${kv} (expected name:type)`);
+            console.error('Supported types: title, rich_text, number, select, multi_select, date, checkbox, url, email, phone_number, status');
+            process.exit(1);
+          }
+          const name = kv.slice(0, colonIdx);
+          const type = kv.slice(colonIdx + 1).toLowerCase();
+          if (type === 'title') hasTitleProp = true;
+          properties[name] = { [type]: {} };
+        }
+
+        // Ensure there's a title property
+        if (!hasTitleProp) {
+          properties['Name'] = { title: {} };
+        }
+
+        // 2025 API: databases.create() only handles title property reliably.
+        // Non-title properties must be added via dataSources.update() after creation.
+        const titleProps = {};
+        const extraProps = {};
+        for (const [name, prop] of Object.entries(properties)) {
+          if (prop.title) {
+            titleProps[name] = prop;
+          } else {
+            extraProps[name] = prop;
+          }
+        }
+        // Ensure title property exists in create call
+        if (Object.keys(titleProps).length === 0) {
+          titleProps['Name'] = { title: {} };
+        }
+
+        const res = await notion.databases.create({
+          parent: { type: 'page_id', page_id: parentPageId },
+          title: [{ text: { content: title } }],
+          properties: titleProps,
+        });
+
+        // Extract correct dual IDs from response
+        const databaseId = res.id;
+        const dataSourceId = (res.data_sources && res.data_sources[0])
+          ? res.data_sources[0].id
+          : res.id;
+
+        // Add non-title properties via dataSources.update()
+        if (Object.keys(extraProps).length > 0) {
+          await notion.dataSources.update({
+            data_source_id: dataSourceId,
+            properties: extraProps,
+          });
+        }
+
+        if (jsonOutput(cmd, res)) return;
+
+        console.log(`✅ Created database: ${databaseId.slice(0, 8)}…`);
+        console.log(`   Title: ${title}`);
+        console.log(`   Properties: ${Object.keys(properties).join(', ')}`);
+
+        // Auto-create alias if requested
+        if (opts.alias) {
+          const config = loadConfig();
+          const wsName = getWorkspaceName() || config.activeWorkspace || 'default';
+          if (!config.workspaces[wsName]) config.workspaces[wsName] = { aliases: {} };
+          if (!config.workspaces[wsName].aliases) config.workspaces[wsName].aliases = {};
+          config.workspaces[wsName].aliases[opts.alias] = {
+            database_id: databaseId,
+            data_source_id: dataSourceId,
+          };
+          saveConfig(config);
+          console.log(`   Alias: ${opts.alias}`);
+        }
+      }));
+
+    // ─── db-update ───────────────────────────────────────────────────────────
+    program
+      .command('db-update <database>')
+      .description('Update a database title or add properties')
+      .option('--title <text>', 'New database title')
+      .option('--add-prop <name:type...>', 'Add a property (e.g. --add-prop "Priority:number")', (v, prev) => prev.concat([v]), [])
+      .option('--remove-prop <name...>', 'Remove a property by name', (v, prev) => prev.concat([v]), [])
+      .action(async (db, opts, cmd) => runCommand('Database update', async () => {
+        const notion = getNotion();
+        const dbIds = resolveDb(db);
+
+        // 2025 API: property changes go through dataSources.update(), NOT databases.update().
+        // databases.update() silently ignores property modifications.
+        // Title changes still go through databases.update().
+        let canonicalId = dbIds.database_id;
+        const dataSourceId = dbIds.data_source_id;
+
+        // Resolve canonical database_id if both IDs are the same
+        if (canonicalId === dataSourceId) {
+          try {
+            const ds = await notion.dataSources.retrieve({ data_source_id: canonicalId });
+            if (ds.parent && ds.parent.type === 'database_id') {
+              canonicalId = ds.parent.database_id;
+            }
+          } catch (_) { /* fall through with what we have */ }
+        }
+
+        // Build property changes for dataSources.update()
+        let propChanges = null;
+        if (opts.addProp.length > 0 || opts.removeProp.length > 0) {
+          propChanges = {};
+
+          for (const kv of opts.addProp) {
+            const colonIdx = kv.indexOf(':');
+            if (colonIdx === -1) {
+              console.error(`Invalid property format: ${kv} (expected name:type)`);
+              process.exit(1);
+            }
+            const name = kv.slice(0, colonIdx);
+            const type = kv.slice(colonIdx + 1).toLowerCase();
+            propChanges[name] = { [type]: {} };
+          }
+
+          for (const name of opts.removeProp) {
+            propChanges[name] = null;
+          }
+        }
+
+        let res;
+
+        // Title changes go through databases.update()
+        if (opts.title) {
+          res = await notion.databases.update({
+            database_id: canonicalId,
+            title: [{ text: { content: opts.title } }],
+          });
+        }
+
+        // Property changes go through dataSources.update()
+        if (propChanges) {
+          res = await notion.dataSources.update({
+            data_source_id: dataSourceId,
+            properties: propChanges,
+          });
+        }
+
+        if (jsonOutput(cmd, res)) return;
+
+        console.log(`✅ Updated database: ${(dbIds.database_id || dbIds.data_source_id).slice(0, 8)}…`);
+        if (opts.title) console.log(`   Title: ${opts.title}`);
+        if (opts.addProp.length > 0) console.log(`   Added: ${opts.addProp.join(', ')}`);
+        if (opts.removeProp.length > 0) console.log(`   Removed: ${opts.removeProp.join(', ')}`);
+      }));
+  },
+};

package/commands/import-export.js

@@ -0,0 +1,162 @@
+const fs = require('fs');
+const path = require('path');
+
+module.exports = {
+  register(program, ctx) {
+    const {
+      getNotion,
+      resolveDb,
+      getDbSchema,
+      buildProperties,
+      parseCsv,
+      markdownToBlocks,
+      blocksToMarkdown,
+      runCommand,
+    } = ctx;
+
+    // ─── import ──────────────────────────────────────────────────────────────
+    program
+      .command('import <file>')
+      .description('Import data from a file (.csv/.json → database pages, .md → page content)')
+      .option('--to <database>', 'Target database alias for CSV/JSON import')
+      .option('--parent <page-id>', 'Parent page for markdown import')
+      .option('--title <text>', 'Page title for markdown import')
+      .action(async (file, opts, cmd) => runCommand('Import', async () => {
+        const filePath = path.resolve(file);
+        if (!fs.existsSync(filePath)) {
+          console.error(`File not found: ${filePath}`);
+          process.exit(1);
+        }
+
+        const ext = path.extname(filePath).toLowerCase();
+        const content = fs.readFileSync(filePath, 'utf-8');
+
+        if (ext === '.csv' || ext === '.json') {
+          // Database import: CSV/JSON → pages
+          if (!opts.to) {
+            console.error('--to <database> is required for CSV/JSON import.');
+            console.error('Example: notion import data.csv --to tasks');
+            process.exit(1);
+          }
+
+          const notion = getNotion();
+          const dbIds = resolveDb(opts.to);
+          const schema = await getDbSchema(dbIds);
+
+          let rows;
+          if (ext === '.csv') {
+            rows = parseCsv(content);
+          } else {
+            const parsed = JSON.parse(content);
+            rows = Array.isArray(parsed) ? parsed : [parsed];
+          }
+
+          if (rows.length === 0) {
+            console.error('No data found in file.');
+            process.exit(1);
+          }
+
+          console.log(`Importing ${rows.length} row${rows.length !== 1 ? 's' : ''} to ${opts.to}...`);
+
+          let created = 0;
+          let failed = 0;
+          for (const row of rows) {
+            try {
+              // Map row keys to schema properties
+              const propStrs = [];
+              for (const [key, value] of Object.entries(row)) {
+                if (value === '' || value === null || value === undefined) continue;
+                const schemaEntry = schema[key.toLowerCase()];
+                if (schemaEntry) {
+                  propStrs.push(`${schemaEntry.name}=${value}`);
+                }
+              }
+              if (propStrs.length === 0) continue;
+
+              const properties = await buildProperties(dbIds, propStrs);
+              await notion.pages.create({
+                parent: { type: 'data_source_id', data_source_id: dbIds.data_source_id },
+                properties,
+              });
+              created++;
+            } catch (err) {
+              failed++;
+              if (failed <= 3) console.error(`  Row failed: ${err.message}`);
+            }
+          }
+
+          console.log(`✅ Imported ${created} page${created !== 1 ? 's' : ''}${failed > 0 ? ` (${failed} failed)` : ''}`);
+
+        } else if (ext === '.md' || ext === '.markdown') {
+          // Page import: Markdown → page with blocks
+          const notion = getNotion();
+          const title = opts.title || path.basename(filePath, ext);
+
+          let parentId = opts.parent;
+          if (!parentId && opts.to) {
+            // If --to is an alias, create as a database page
+            const dbIds = resolveDb(opts.to);
+            const properties = await buildProperties(dbIds, [`Name=${title}`]);
+            const res = await notion.pages.create({
+              parent: { type: 'data_source_id', data_source_id: dbIds.data_source_id },
+              properties,
+            });
+            parentId = res.id;
+            console.log(`✅ Created page: ${res.id}`);
+          } else if (parentId) {
+            // Create as a child page
+            const res = await notion.pages.create({
+              parent: { type: 'page_id', page_id: parentId },
+              properties: { title: { title: [{ text: { content: title } }] } },
+            });
+            parentId = res.id;
+            console.log(`✅ Created page: ${res.id}`);
+          } else {
+            console.error('Specify --to <database> or --parent <page-id> for markdown import.');
+            process.exit(1);
+          }
+
+          // Parse markdown and append blocks
+          const blocks = markdownToBlocks(content);
+          for (let i = 0; i < blocks.length; i += 100) {
+            await notion.blocks.children.append({
+              block_id: parentId,
+              children: blocks.slice(i, i + 100),
+            });
+          }
+
+          console.log(`   Imported ${blocks.length} block${blocks.length !== 1 ? 's' : ''} from ${path.basename(filePath)}`);
+        } else {
+          console.error(`Unsupported file type: ${ext}`);
+          console.error('Supported: .csv, .json (→ database), .md (→ page)');
+          process.exit(1);
+        }
+      }));
+
+    // ─── export ──────────────────────────────────────────────────────────────
+    program
+      .command('export <page-or-alias>')
+      .description('Export page content as markdown')
+      .option('--filter <key=value>', 'Filter to find the page (required when using an alias)')
+      .action(async (target, opts, cmd) => runCommand('Export', async () => {
+        const notion = getNotion();
+        const { pageId } = await ctx.resolvePageId(target, opts.filter);
+
+        // Fetch all blocks
+        let blocks = [];
+        let cursor;
+        do {
+          const res = await notion.blocks.children.list({
+            block_id: pageId,
+            start_cursor: cursor,
+            page_size: 100,
+          });
+          blocks = blocks.concat(res.results);
+          cursor = res.has_more ? res.next_cursor : null;
+        } while (cursor);
+
+        const md = blocksToMarkdown(blocks);
+        console.log(md);
+      }));
+  },
+};