@iwo-szapar/data-mcp 0.3.3 → 0.5.0

package/dist/tools/setup/setup-migrate.js

@@ -3,8 +3,16 @@
  *
  * Apply migrations — additive only, skips existing collections.
  * Creates all expected collections in the database.
+ *
+ * RC-3 fix (incident 2026-05-11): Replaced hardcoded project-relative
+ * "migrations/supabase/" string with runtime-resolved absolute path to
+ * the bundled SQL files inside this package.
  */
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { makeToolResponse, makeErrorResponse } from '../shared.js';
+const PACKAGE_MIGRATIONS_SUPABASE = join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..', 'migrations', 'supabase');
+const PACKAGE_MIGRATIONS_POCKETBASE = join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..', 'migrations', 'pocketbase');
 /** Collection schemas for PocketBase creation */
 const COLLECTION_SCHEMAS = [
     { name: 'knowledge', description: 'Knowledge items (facts, patterns, insights, lessons, references)' },
@@ -23,10 +31,11 @@ const COLLECTION_SCHEMAS = [
     { name: 'affiliates', description: 'Affiliate partners and commissions' },
 ];
 export function registerSetupMigrate(server, adapter) {
-    server.tool('setup_migrate', 'Create missing database collections/tables. Additive only — existing collections are skipped. For PocketBase, creates collections via API. For Supabase, reports SQL migrations to run manually.', {}, async () => {
+    server.tool('setup_migrate', 'Create missing database collections/tables. Additive only — existing collections are skipped. For PocketBase, creates collections via API. For Supabase, reports SQL migrations and recommends running setup_bootstrap for paste-ready SQL.', {}, async () => {
         try {
             const skipped = [];
             const needsMigration = [];
+            const migrationsPath = adapter.backend === 'supabase' ? PACKAGE_MIGRATIONS_SUPABASE : PACKAGE_MIGRATIONS_POCKETBASE;
             for (const schema of COLLECTION_SCHEMAS) {
                 try {
                     const exists = await adapter.collectionExists(schema.name);
@@ -34,18 +43,12 @@ export function registerSetupMigrate(server, adapter) {
                         skipped.push(schema.name);
                         continue;
                     }
-                    if (adapter.backend === 'supabase') {
-                        needsMigration.push({
-                            name: schema.name,
-                            instruction: 'Run SQL migrations from migrations/supabase/ directory.',
-                        });
-                    }
-                    else {
-                        needsMigration.push({
-                            name: schema.name,
-                            instruction: 'Run PocketBase migrations from migrations/pocketbase/ directory.',
-                        });
-                    }
+                    needsMigration.push({
+                        name: schema.name,
+                        instruction: adapter.backend === 'supabase'
+                            ? `Apply SQL from ${migrationsPath}/. Easiest path: call setup_bootstrap for a paste-ready SQL block.`
+                            : `Apply migration from ${migrationsPath}/.`,
+                    });
                 }
                 catch (err) {
                     const msg = err instanceof Error ? err.message : 'Unknown error';
@@ -55,6 +58,7 @@ export function registerSetupMigrate(server, adapter) {
             }
             return makeToolResponse({
                 backend: adapter.backend,
+                migrations_path: migrationsPath,
                 existing: skipped.length,
                 needs_migration: needsMigration.length,
                 details: {
@@ -62,8 +66,8 @@ export function registerSetupMigrate(server, adapter) {
                     needs_migration: needsMigration.length > 0 ? needsMigration : undefined,
                 },
                 message: adapter.backend === 'pocketbase'
-                    ? `Schema check complete. ${skipped.length} existing, ${needsMigration.length} need migration files. Run PocketBase migrations from migrations/pocketbase/ directory.`
-                    : `Schema check complete. ${skipped.length} existing, ${needsMigration.length} need SQL migrations. Apply migrations from migrations/supabase/ directory.`,
+                    ? `Schema check complete. ${skipped.length} existing, ${needsMigration.length} need migration files. Apply from ${migrationsPath}/.`
+                    : `Schema check complete. ${skipped.length} existing, ${needsMigration.length} need SQL. Run setup_bootstrap for a paste-ready block, or apply from ${migrationsPath}/ manually.`,
             });
         }
         catch (error) {
@@ -72,4 +76,4 @@ export function registerSetupMigrate(server, adapter) {
         }
     });
 }
-//# sourceMappingURL=setup-migrate.js.map
+//# sourceMappingURL=setup-migrate.js.map

package/dist/tools/setup/setup-status.js

@@ -2,6 +2,13 @@
  * Tool: setup_status
  *
  * Check backend connection, list existing/missing collections, report status.
+ *
+ * RC-1 fix (incident 2026-05-11): Previously called adapter.listCollections()
+ * which uses rpc('get_public_tables') — a custom Postgres function absent from
+ * fresh Supabase projects. Fallback to information_schema also failed because
+ * PostgREST only exposes the public schema. Now uses the same code path as
+ * setup_migrate (adapter.collectionExists per expected collection) so the
+ * diagnostic agrees with the data tools.
  */
 import { makeToolResponse, makeErrorResponse } from '../shared.js';
 const EXPECTED_COLLECTIONS = [
@@ -23,20 +30,18 @@ const EXPECTED_COLLECTIONS = [
 export function registerSetupStatus(server, adapter) {
     server.tool('setup_status', 'Check database connection status, list existing and missing collections, and report schema readiness.', {}, { readOnlyHint: true }, async () => {
         try {
-            // Test connection by listing collections
-            const existing = await adapter.listCollections();
-            const existingSet = new Set(existing);
             const present = [];
             const missing = [];
             for (const collection of EXPECTED_COLLECTIONS) {
-                if (existingSet.has(collection)) {
+                const exists = await adapter.collectionExists(collection);
+                if (exists) {
                     present.push(collection);
                 }
                 else {
                     missing.push(collection);
                 }
             }
-            // Check for settings table and schema version
+            const existingSet = new Set(present);
             let schemaVersion = null;
             if (existingSet.has('settings')) {
                 try {
@@ -75,4 +80,4 @@ export function registerSetupStatus(server, adapter) {
         }
     });
 }
-//# sourceMappingURL=setup-status.js.map
+//# sourceMappingURL=setup-status.js.map

package/migrations/pocketbase/001_core_schema.js

@@ -2,26 +2,24 @@
  * PocketBase Migration 001: Core schema
  *
  * Creates knowledge, decisions, sessions collections.
- * PocketBase v0.23+ field format.
  */
 
 /// <reference path="../pb_data/types.d.ts" />
 
 migrate((app) => {
+  // knowledge collection
   const knowledge = new Collection({
     name: 'knowledge',
     type: 'base',
-    fields: [
-      { name: 'type', type: 'select', required: true, maxSelect: 1, values: ['fact', 'knowledge', 'pattern', 'insight', 'lesson', 'reference'] },
-      { name: 'title', type: 'text', required: true, max: 500 },
-      { name: 'content', type: 'editor', required: true, maxSize: 50000 },
-      { name: 'summary', type: 'text', max: 2000 },
+    schema: [
+      { name: 'type', type: 'select', required: true, options: { values: ['fact', 'knowledge', 'pattern', 'insight', 'lesson', 'reference'] } },
+      { name: 'title', type: 'text', required: true, options: { maxSize: 500 } },
+      { name: 'content', type: 'editor', required: true, options: { maxSize: 50000 } },
+      { name: 'summary', type: 'text', options: { maxSize: 2000 } },
       { name: 'tags', type: 'json' },
-      { name: 'source', type: 'text', max: 500 },
-      { name: 'confidence', type: 'number', min: 0, max: 1 },
+      { name: 'source', type: 'text', options: { maxSize: 500 } },
+      { name: 'confidence', type: 'number', options: { min: 0, max: 1 } },
       { name: 'last_validated_at', type: 'date' },
-      { name: 'created', type: 'autodate', onCreate: true },
-      { name: 'updated', type: 'autodate', onCreate: true, onUpdate: true },
     ],
     indexes: [
       'CREATE INDEX idx_knowledge_type ON knowledge (type)',
@@ -30,47 +28,45 @@ migrate((app) => {
   });
   app.save(knowledge);
 
+  // decisions collection
   const decisions = new Collection({
     name: 'decisions',
     type: 'base',
-    fields: [
-      { name: 'title', type: 'text', required: true, max: 500 },
-      { name: 'context', type: 'editor', maxSize: 5000 },
+    schema: [
+      { name: 'title', type: 'text', required: true, options: { maxSize: 500 } },
+      { name: 'context', type: 'editor', options: { maxSize: 5000 } },
       { name: 'options_considered', type: 'json', required: true },
-      { name: 'chosen_option', type: 'text', required: true, max: 500 },
-      { name: 'rationale', type: 'editor', maxSize: 5000 },
-      { name: 'outcome', type: 'editor', maxSize: 5000 },
+      { name: 'chosen_option', type: 'text', required: true, options: { maxSize: 500 } },
+      { name: 'rationale', type: 'editor', options: { maxSize: 5000 } },
+      { name: 'outcome', type: 'editor', options: { maxSize: 5000 } },
       { name: 'tags', type: 'json' },
-      { name: 'created', type: 'autodate', onCreate: true },
-      { name: 'updated', type: 'autodate', onCreate: true, onUpdate: true },
     ],
   });
   app.save(decisions);
 
+  // sessions collection
   const sessions = new Collection({
     name: 'sessions',
     type: 'base',
-    fields: [
-      { name: 'title', type: 'text', required: true, max: 500 },
-      { name: 'summary', type: 'editor', required: true, maxSize: 10000 },
+    schema: [
+      { name: 'title', type: 'text', required: true, options: { maxSize: 500 } },
+      { name: 'summary', type: 'editor', required: true, options: { maxSize: 10000 } },
       { name: 'session_date', type: 'date' },
       { name: 'skills_used', type: 'json' },
       { name: 'files_changed', type: 'json' },
       { name: 'decisions_made', type: 'json' },
       { name: 'duration_minutes', type: 'number' },
-      { name: 'task_id', type: 'text', max: 100 },
-      { name: 'branch', type: 'text', max: 200 },
+      { name: 'task_id', type: 'text', options: { maxSize: 100 } },
+      { name: 'branch', type: 'text', options: { maxSize: 200 } },
       { name: 'patterns_learned', type: 'json' },
       { name: 'knowledge_created', type: 'number' },
       { name: 'knowledge_updated', type: 'number' },
       { name: 'metadata', type: 'json' },
-      { name: 'created', type: 'autodate', onCreate: true },
-      { name: 'updated', type: 'autodate', onCreate: true, onUpdate: true },
     ],
   });
   app.save(sessions);
 }, (app) => {
-  const c1 = app.findCollectionByNameOrId('sessions'); if (c1) app.delete(c1);
-  const c2 = app.findCollectionByNameOrId('decisions'); if (c2) app.delete(c2);
-  const c3 = app.findCollectionByNameOrId('knowledge'); if (c3) app.delete(c3);
+  app.delete(app.findCollectionByNameOrId('sessions'));
+  app.delete(app.findCollectionByNameOrId('decisions'));
+  app.delete(app.findCollectionByNameOrId('knowledge'));
 });

package/migrations/pocketbase/002_goals_tasks.js

@@ -1,23 +1,21 @@
 /**
  * PocketBase Migration 002: Goals and tasks
- * PocketBase v0.23+ field format.
  */
 
 /// <reference path="../pb_data/types.d.ts" />
 
 migrate((app) => {
+  // goals collection
   const goals = new Collection({
     name: 'goals',
     type: 'base',
-    fields: [
-      { name: 'title', type: 'text', required: true, max: 500 },
-      { name: 'description', type: 'editor', maxSize: 5000 },
-      { name: 'timeframe', type: 'select', required: true, maxSelect: 1, values: ['daily', 'weekly', 'monthly', 'quarterly', 'yearly'] },
-      { name: 'status', type: 'select', required: true, maxSelect: 1, values: ['active', 'completed', 'paused', 'abandoned'] },
+    schema: [
+      { name: 'title', type: 'text', required: true, options: { maxSize: 500 } },
+      { name: 'description', type: 'editor', options: { maxSize: 5000 } },
+      { name: 'timeframe', type: 'select', required: true, options: { values: ['daily', 'weekly', 'monthly', 'quarterly', 'yearly'] } },
+      { name: 'status', type: 'select', required: true, options: { values: ['active', 'completed', 'paused', 'abandoned'] } },
       { name: 'key_results', type: 'json' },
       { name: 'tags', type: 'json' },
-      { name: 'created', type: 'autodate', onCreate: true },
-      { name: 'updated', type: 'autodate', onCreate: true, onUpdate: true },
     ],
     indexes: [
       'CREATE INDEX idx_goals_status ON goals (status)',
@@ -26,19 +24,18 @@ migrate((app) => {
   });
   app.save(goals);
 
+  // tasks collection
   const tasks = new Collection({
     name: 'tasks',
     type: 'base',
-    fields: [
-      { name: 'title', type: 'text', required: true, max: 500 },
-      { name: 'description', type: 'editor', maxSize: 5000 },
-      { name: 'status', type: 'select', required: true, maxSelect: 1, values: ['todo', 'in_progress', 'done', 'cancelled'] },
-      { name: 'priority', type: 'select', required: true, maxSelect: 1, values: ['low', 'medium', 'high', 'urgent'] },
+    schema: [
+      { name: 'title', type: 'text', required: true, options: { maxSize: 500 } },
+      { name: 'description', type: 'editor', options: { maxSize: 5000 } },
+      { name: 'status', type: 'select', required: true, options: { values: ['todo', 'in_progress', 'done', 'cancelled'] } },
+      { name: 'priority', type: 'select', required: true, options: { values: ['low', 'medium', 'high', 'urgent'] } },
       { name: 'due_date', type: 'date' },
       { name: 'tags', type: 'json' },
-      { name: 'goal_id', type: 'text', max: 100 },
-      { name: 'created', type: 'autodate', onCreate: true },
-      { name: 'updated', type: 'autodate', onCreate: true, onUpdate: true },
+      { name: 'goal_id', type: 'text', options: { maxSize: 100 } },
     ],
     indexes: [
       'CREATE INDEX idx_tasks_status ON tasks (status)',
@@ -47,6 +44,6 @@ migrate((app) => {
   });
   app.save(tasks);
 }, (app) => {
-  const t = app.findCollectionByNameOrId('tasks'); if (t) app.delete(t);
-  const g = app.findCollectionByNameOrId('goals'); if (g) app.delete(g);
+  app.delete(app.findCollectionByNameOrId('tasks'));
+  app.delete(app.findCollectionByNameOrId('goals'));
 });

package/migrations/pocketbase/003_contacts.js

@@ -1,6 +1,5 @@
 /**
  * PocketBase Migration 003: Contacts
- * PocketBase v0.23+ field format.
  */
 
 /// <reference path="../pb_data/types.d.ts" />
@@ -9,18 +8,16 @@ migrate((app) => {
   const contacts = new Collection({
     name: 'contacts',
     type: 'base',
-    fields: [
-      { name: 'name', type: 'text', required: true, max: 200 },
-      { name: 'company', type: 'text', max: 200 },
-      { name: 'role', type: 'text', max: 200 },
-      { name: 'email', type: 'email' },
-      { name: 'phone', type: 'text', max: 50 },
-      { name: 'relationship', type: 'select', maxSelect: 1, values: ['colleague', 'client', 'prospect', 'partner', 'other'] },
-      { name: 'notes', type: 'editor', maxSize: 5000 },
+    schema: [
+      { name: 'name', type: 'text', required: true, options: { maxSize: 200 } },
+      { name: 'company', type: 'text', options: { maxSize: 200 } },
+      { name: 'role', type: 'text', options: { maxSize: 200 } },
+      { name: 'email', type: 'email', options: { maxSize: 200 } },
+      { name: 'phone', type: 'text', options: { maxSize: 50 } },
+      { name: 'relationship', type: 'select', options: { values: ['colleague', 'client', 'prospect', 'partner', 'other'] } },
+      { name: 'notes', type: 'editor', options: { maxSize: 5000 } },
       { name: 'tags', type: 'json' },
       { name: 'last_contact_date', type: 'date' },
-      { name: 'created', type: 'autodate', onCreate: true },
-      { name: 'updated', type: 'autodate', onCreate: true, onUpdate: true },
     ],
     indexes: [
       'CREATE INDEX idx_contacts_name ON contacts (name)',
@@ -28,5 +25,5 @@ migrate((app) => {
   });
   app.save(contacts);
 }, (app) => {
-  const c = app.findCollectionByNameOrId('contacts'); if (c) app.delete(c);
+  app.delete(app.findCollectionByNameOrId('contacts'));
 });

package/migrations/pocketbase/004_entity_aliases.js

@@ -1,19 +1,17 @@
 /**
  * PocketBase Migration 004: Entity aliases + settings
- * PocketBase v0.23+ field format.
  */
 
 /// <reference path="../pb_data/types.d.ts" />
 
 migrate((app) => {
+  // entity_aliases collection
   const aliases = new Collection({
     name: 'entity_aliases',
     type: 'base',
-    fields: [
-      { name: 'canonical', type: 'text', required: true, max: 100 },
-      { name: 'alias', type: 'text', required: true, max: 200 },
-      { name: 'created', type: 'autodate', onCreate: true },
-      { name: 'updated', type: 'autodate', onCreate: true, onUpdate: true },
+    schema: [
+      { name: 'canonical', type: 'text', required: true, options: { maxSize: 100 } },
+      { name: 'alias', type: 'text', required: true, options: { maxSize: 200 } },
     ],
     indexes: [
       'CREATE UNIQUE INDEX idx_entity_aliases_unique ON entity_aliases (canonical, alias)',
@@ -23,14 +21,13 @@ migrate((app) => {
   });
   app.save(aliases);
 
+  // settings collection
   const settings = new Collection({
     name: 'settings',
     type: 'base',
-    fields: [
-      { name: 'key', type: 'text', required: true, max: 100 },
+    schema: [
+      { name: 'key', type: 'text', required: true, options: { maxSize: 100 } },
       { name: 'value', type: 'editor' },
-      { name: 'created', type: 'autodate', onCreate: true },
-      { name: 'updated', type: 'autodate', onCreate: true, onUpdate: true },
     ],
     indexes: [
       'CREATE UNIQUE INDEX idx_settings_key ON settings (key)',
@@ -38,6 +35,6 @@ migrate((app) => {
   });
   app.save(settings);
 }, (app) => {
-  const s = app.findCollectionByNameOrId('settings'); if (s) app.delete(s);
-  const a = app.findCollectionByNameOrId('entity_aliases'); if (a) app.delete(a);
+  app.delete(app.findCollectionByNameOrId('settings'));
+  app.delete(app.findCollectionByNameOrId('entity_aliases'));
 });

package/migrations/pocketbase/005_prospects.js

@@ -1,6 +1,5 @@
 /**
  * PocketBase Migration 005: Prospects (CRM)
- * PocketBase v0.23+ field format.
  */
 
 /// <reference path="../pb_data/types.d.ts" />
@@ -9,22 +8,20 @@ migrate((app) => {
   const prospects = new Collection({
     name: 'prospects',
     type: 'base',
-    fields: [
-      { name: 'name', type: 'text', required: true, max: 200 },
-      { name: 'email', type: 'email' },
-      { name: 'company', type: 'text', max: 200 },
-      { name: 'role', type: 'text', max: 200 },
-      { name: 'stage', type: 'select', required: true, maxSelect: 1, values: ['new', 'contacted', 'responded', 'interested', 'ready_to_buy', 'proposal_sent', 'negotiating', 'closed_won', 'closed_lost', 'nurturing'] },
-      { name: 'source', type: 'text', max: 200 },
+    schema: [
+      { name: 'name', type: 'text', required: true, options: { maxSize: 200 } },
+      { name: 'email', type: 'email', options: { maxSize: 200 } },
+      { name: 'company', type: 'text', options: { maxSize: 200 } },
+      { name: 'role', type: 'text', options: { maxSize: 200 } },
+      { name: 'stage', type: 'select', required: true, options: { values: ['new', 'contacted', 'responded', 'interested', 'ready_to_buy', 'proposal_sent', 'negotiating', 'closed_won', 'closed_lost', 'nurturing'] } },
+      { name: 'source', type: 'text', options: { maxSize: 200 } },
       { name: 'estimated_value', type: 'number' },
-      { name: 'next_action_type', type: 'text', max: 100 },
+      { name: 'next_action_type', type: 'text', options: { maxSize: 100 } },
       { name: 'next_followup_date', type: 'date' },
       { name: 'last_contact_date', type: 'date' },
-      { name: 'notes', type: 'editor', maxSize: 10000 },
+      { name: 'notes', type: 'editor', options: { maxSize: 10000 } },
       { name: 'tags', type: 'json' },
-      { name: 'linkedin_url', type: 'url' },
-      { name: 'created', type: 'autodate', onCreate: true },
-      { name: 'updated', type: 'autodate', onCreate: true, onUpdate: true },
+      { name: 'linkedin_url', type: 'url', options: { maxSize: 500 } },
     ],
     indexes: [
       'CREATE INDEX idx_prospects_stage ON prospects (stage)',
@@ -32,5 +29,5 @@ migrate((app) => {
   });
   app.save(prospects);
 }, (app) => {
-  const p = app.findCollectionByNameOrId('prospects'); if (p) app.delete(p);
+  app.delete(app.findCollectionByNameOrId('prospects'));
 });

package/migrations/pocketbase/006_business.js

@@ -1,27 +1,25 @@
 /**
  * PocketBase Migration 006: Business collections (blog, email, content)
- * PocketBase v0.23+ field format.
  */
 
 /// <reference path="../pb_data/types.d.ts" />
 
 migrate((app) => {
+  // blog_posts collection
   const blogPosts = new Collection({
     name: 'blog_posts',
     type: 'base',
-    fields: [
-      { name: 'title', type: 'text', required: true, max: 500 },
-      { name: 'slug', type: 'text', required: true, max: 200 },
+    schema: [
+      { name: 'title', type: 'text', required: true, options: { maxSize: 500 } },
+      { name: 'slug', type: 'text', required: true, options: { maxSize: 200 } },
       { name: 'content', type: 'editor', required: true },
-      { name: 'excerpt', type: 'text', max: 500 },
-      { name: 'status', type: 'select', required: true, maxSelect: 1, values: ['draft', 'published', 'archived'] },
+      { name: 'excerpt', type: 'text', options: { maxSize: 500 } },
+      { name: 'status', type: 'select', required: true, options: { values: ['draft', 'published', 'archived'] } },
       { name: 'published_at', type: 'date' },
       { name: 'tags', type: 'json' },
-      { name: 'seo_title', type: 'text', max: 200 },
-      { name: 'seo_description', type: 'text', max: 300 },
-      { name: 'og_image_url', type: 'url' },
-      { name: 'created', type: 'autodate', onCreate: true },
-      { name: 'updated', type: 'autodate', onCreate: true, onUpdate: true },
+      { name: 'seo_title', type: 'text', options: { maxSize: 200 } },
+      { name: 'seo_description', type: 'text', options: { maxSize: 300 } },
+      { name: 'og_image_url', type: 'url', options: { maxSize: 500 } },
     ],
     indexes: [
       'CREATE UNIQUE INDEX idx_blog_posts_slug ON blog_posts (slug)',
@@ -30,25 +28,24 @@ migrate((app) => {
   });
   app.save(blogPosts);
 
+  // email_queue collection
   const emailQueue = new Collection({
     name: 'email_queue',
     type: 'base',
-    fields: [
-      { name: 'to_email', type: 'email', required: true },
-      { name: 'to_name', type: 'text', max: 200 },
-      { name: 'subject', type: 'text', required: true, max: 500 },
+    schema: [
+      { name: 'to_email', type: 'email', required: true, options: { maxSize: 200 } },
+      { name: 'to_name', type: 'text', options: { maxSize: 200 } },
+      { name: 'subject', type: 'text', required: true, options: { maxSize: 500 } },
       { name: 'body_html', type: 'editor', required: true },
       { name: 'body_text', type: 'editor' },
-      { name: 'status', type: 'select', required: true, maxSelect: 1, values: ['queued', 'sent', 'failed', 'bounced'] },
-      { name: 'sequence_id', type: 'text', max: 100 },
+      { name: 'status', type: 'select', required: true, options: { values: ['queued', 'sent', 'failed', 'bounced'] } },
+      { name: 'sequence_id', type: 'text', options: { maxSize: 100 } },
       { name: 'sequence_step', type: 'number' },
-      { name: 'prospect_id', type: 'text', max: 100 },
+      { name: 'prospect_id', type: 'text', options: { maxSize: 100 } },
       { name: 'scheduled_at', type: 'date' },
       { name: 'sent_at', type: 'date' },
       { name: 'error', type: 'editor' },
-      { name: 'resend_id', type: 'text', max: 200 },
-      { name: 'created', type: 'autodate', onCreate: true },
-      { name: 'updated', type: 'autodate', onCreate: true, onUpdate: true },
+      { name: 'resend_id', type: 'text', options: { maxSize: 200 } },
     ],
     indexes: [
       'CREATE INDEX idx_email_queue_status ON email_queue (status)',
@@ -56,20 +53,19 @@ migrate((app) => {
   });
   app.save(emailQueue);
 
+  // content_calendar collection
   const contentCalendar = new Collection({
     name: 'content_calendar',
     type: 'base',
-    fields: [
-      { name: 'title', type: 'text', required: true, max: 500 },
+    schema: [
+      { name: 'title', type: 'text', required: true, options: { maxSize: 500 } },
       { name: 'content', type: 'editor' },
-      { name: 'platform', type: 'select', required: true, maxSelect: 1, values: ['linkedin', 'newsletter', 'blog', 'twitter', 'other'] },
-      { name: 'pillar', type: 'text', max: 100 },
-      { name: 'status', type: 'select', required: true, maxSelect: 1, values: ['idea', 'drafting', 'ready', 'published'] },
+      { name: 'platform', type: 'select', required: true, options: { values: ['linkedin', 'newsletter', 'blog', 'twitter', 'other'] } },
+      { name: 'pillar', type: 'text', options: { maxSize: 100 } },
+      { name: 'status', type: 'select', required: true, options: { values: ['idea', 'drafting', 'ready', 'published'] } },
       { name: 'scheduled_date', type: 'date' },
-      { name: 'published_url', type: 'url' },
-      { name: 'persona', type: 'text', max: 100 },
-      { name: 'created', type: 'autodate', onCreate: true },
-      { name: 'updated', type: 'autodate', onCreate: true, onUpdate: true },
+      { name: 'published_url', type: 'url', options: { maxSize: 500 } },
+      { name: 'persona', type: 'text', options: { maxSize: 100 } },
     ],
     indexes: [
       'CREATE INDEX idx_content_calendar_platform ON content_calendar (platform)',
@@ -78,7 +74,7 @@ migrate((app) => {
   });
   app.save(contentCalendar);
 }, (app) => {
-  const cc = app.findCollectionByNameOrId('content_calendar'); if (cc) app.delete(cc);
-  const eq = app.findCollectionByNameOrId('email_queue'); if (eq) app.delete(eq);
-  const bp = app.findCollectionByNameOrId('blog_posts'); if (bp) app.delete(bp);
+  app.delete(app.findCollectionByNameOrId('content_calendar'));
+  app.delete(app.findCollectionByNameOrId('email_queue'));
+  app.delete(app.findCollectionByNameOrId('blog_posts'));
 });

package/migrations/pocketbase/007_newsletter_affiliates.js

@@ -1,24 +1,22 @@
 /**
  * PocketBase Migration 007: Newsletter subscribers and affiliates
- * PocketBase v0.23+ field format.
  */
 
 /// <reference path="../pb_data/types.d.ts" />
 
 migrate((app) => {
+  // newsletter_subscribers collection
   const subscribers = new Collection({
     name: 'newsletter_subscribers',
     type: 'base',
-    fields: [
-      { name: 'email', type: 'email', required: true },
-      { name: 'name', type: 'text', max: 200 },
-      { name: 'status', type: 'select', required: true, maxSelect: 1, values: ['active', 'unsubscribed', 'bounced'] },
-      { name: 'source', type: 'text', max: 200 },
+    schema: [
+      { name: 'email', type: 'email', required: true, options: { maxSize: 200 } },
+      { name: 'name', type: 'text', options: { maxSize: 200 } },
+      { name: 'status', type: 'select', required: true, options: { values: ['active', 'unsubscribed', 'bounced'] } },
+      { name: 'source', type: 'text', options: { maxSize: 200 } },
       { name: 'tags', type: 'json' },
       { name: 'subscribed_at', type: 'date' },
       { name: 'unsubscribed_at', type: 'date' },
-      { name: 'created', type: 'autodate', onCreate: true },
-      { name: 'updated', type: 'autodate', onCreate: true, onUpdate: true },
     ],
     indexes: [
       'CREATE UNIQUE INDEX idx_newsletter_subscribers_email ON newsletter_subscribers (email)',
@@ -26,20 +24,19 @@ migrate((app) => {
   });
   app.save(subscribers);
 
+  // affiliates collection
   const affiliates = new Collection({
     name: 'affiliates',
     type: 'base',
-    fields: [
-      { name: 'name', type: 'text', required: true, max: 200 },
-      { name: 'email', type: 'email', required: true },
-      { name: 'code', type: 'text', required: true, max: 100 },
-      { name: 'commission_rate', type: 'number', min: 0, max: 1 },
-      { name: 'status', type: 'select', required: true, maxSelect: 1, values: ['pending', 'active', 'paused', 'terminated'] },
+    schema: [
+      { name: 'name', type: 'text', required: true, options: { maxSize: 200 } },
+      { name: 'email', type: 'email', required: true, options: { maxSize: 200 } },
+      { name: 'code', type: 'text', required: true, options: { maxSize: 100 } },
+      { name: 'commission_rate', type: 'number', options: { min: 0, max: 1 } },
+      { name: 'status', type: 'select', required: true, options: { values: ['pending', 'active', 'paused', 'terminated'] } },
       { name: 'total_earned_cents', type: 'number' },
       { name: 'total_paid_cents', type: 'number' },
-      { name: 'stripe_account_id', type: 'text', max: 200 },
-      { name: 'created', type: 'autodate', onCreate: true },
-      { name: 'updated', type: 'autodate', onCreate: true, onUpdate: true },
+      { name: 'stripe_account_id', type: 'text', options: { maxSize: 200 } },
     ],
     indexes: [
       'CREATE UNIQUE INDEX idx_affiliates_email ON affiliates (email)',
@@ -48,6 +45,6 @@ migrate((app) => {
   });
   app.save(affiliates);
 }, (app) => {
-  const a = app.findCollectionByNameOrId('affiliates'); if (a) app.delete(a);
-  const s = app.findCollectionByNameOrId('newsletter_subscribers'); if (s) app.delete(s);
+  app.delete(app.findCollectionByNameOrId('affiliates'));
+  app.delete(app.findCollectionByNameOrId('newsletter_subscribers'));
 });