@iwo-szapar/data-mcp 0.4.0 → 0.6.0

package/dist/tools/memory/session-log.js

@@ -24,6 +24,7 @@ export function registerSessionLog(server, adapter) {
         })).optional().describe('Patterns learned during the session'),
         knowledge_created: z.number().int().min(0).optional().describe('Number of knowledge items created'),
         knowledge_updated: z.number().int().min(0).optional().describe('Number of knowledge items updated'),
+        owner_scope: z.enum(['private', 'shared']).optional().describe('Store privately for this user or in shared team memory'),
         metadata: z.record(z.unknown()).optional().describe('Additional metadata'),
     }, withGracefulDegradation('sessions', adapter, async (params) => {
         try {
@@ -40,6 +41,7 @@ export function registerSessionLog(server, adapter) {
                 patterns_learned: params.patterns_learned ?? [],
                 knowledge_created: params.knowledge_created ?? 0,
                 knowledge_updated: params.knowledge_updated ?? 0,
+                ...(adapter.ownerScopeEnabled ? { owner_scope: params.owner_scope } : {}),
                 metadata: params.metadata ?? null,
             });
             return makeToolResponse({
@@ -53,4 +55,4 @@ export function registerSessionLog(server, adapter) {
         }
     }));
 }
-//# sourceMappingURL=session-log.js.map
+//# sourceMappingURL=session-log.js.map

package/dist/tools/memory/task-create.js

@@ -13,6 +13,7 @@ export function registerTaskCreate(server, adapter) {
         due_date: z.string().max(50).optional().describe('Due date (ISO format)'),
         tags: z.array(z.string().max(100)).max(20).optional().describe('Tags for categorization'),
         goal_id: z.string().min(1).optional().describe('Related goal ID'),
+        owner_scope: z.enum(['private', 'shared']).optional().describe('Store privately for this user or in shared team memory'),
     }, withGracefulDegradation('tasks', adapter, async (params) => {
         try {
             const record = await adapter.create('tasks', {
@@ -23,6 +24,7 @@ export function registerTaskCreate(server, adapter) {
                 due_date: params.due_date ?? null,
                 tags: params.tags ?? [],
                 goal_id: params.goal_id ?? null,
+                ...(adapter.ownerScopeEnabled ? { owner_scope: params.owner_scope } : {}),
             });
             return makeToolResponse({
                 created: true,
@@ -35,4 +37,4 @@ export function registerTaskCreate(server, adapter) {
         }
     }));
 }
-//# sourceMappingURL=task-create.js.map
+//# sourceMappingURL=task-create.js.map

package/dist/tools/register.js

@@ -28,9 +28,10 @@ import { registerLinkCreate } from './memory/link-create.js';
 import { registerLinkDelete } from './memory/link-delete.js';
 import { registerLinkRelated } from './memory/link-related.js';
 import { registerLinkSuggest } from './memory/link-suggest.js';
-// Setup tools (3)
+// Setup tools (4)
 import { registerSetupStatus } from './setup/setup-status.js';
 import { registerSetupMigrate } from './setup/setup-migrate.js';
+import { registerSetupBootstrap } from './setup/setup-bootstrap.js';
 import { registerSetupSeed } from './setup/setup-seed.js';
 // Business tools (11)
 import { registerProspectCreate } from './business/prospect-create.js';
@@ -75,6 +76,7 @@ export function registerAllTools(server, adapter) {
     // Setup tools
     registerSetupStatus(server, adapter);
     registerSetupMigrate(server, adapter);
+    registerSetupBootstrap(server, adapter);
     registerSetupSeed(server, adapter);
     // Business tools
     registerProspectCreate(server, adapter);

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

@@ -0,0 +1,71 @@
+/**
+ * Tool: setup_bootstrap
+ *
+ * RC-2 fix (incident 2026-05-11): Generates a single SQL block containing
+ * every bundled Supabase migration concatenated in numeric order, followed
+ * by NOTIFY pgrst, 'reload schema'. Customer pastes the block into the
+ * Supabase SQL Editor and runs it once. Stops short of running the SQL
+ * itself because Supabase service-role over PostgREST does not expose
+ * arbitrary SQL execution — that needs either a custom exec_sql function
+ * (Approach B, opt-in by customer) or the Management API with a personal
+ * access token (Approach C, adds auth surface). This is Approach A: lowest
+ * friction, no new auth, works on Cloud + self-hosted.
+ *
+ * After the customer runs the block, setup_migrate will report all
+ * collections present.
+ */
+import { readFileSync, readdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { makeToolResponse, makeErrorResponse } from '../shared.js';
+const MIGRATIONS_DIR = join(dirname(fileURLToPath(import.meta.url)), '..', '..', '..', 'migrations', 'supabase');
+export function registerSetupBootstrap(server, adapter) {
+    server.tool('setup_bootstrap', 'Generate a paste-ready SQL block (all bundled Supabase migrations + PostgREST reload). Open the returned sql_editor_url, paste sql, run. Idempotent. Supabase backend only — PocketBase customers use setup_migrate.', {}, async () => {
+        if (adapter.backend !== 'supabase') {
+            return makeErrorResponse('setup_bootstrap is Supabase-only. PocketBase customers use setup_migrate.');
+        }
+        try {
+            const files = readdirSync(MIGRATIONS_DIR).filter((f) => f.endsWith('.sql')).sort();
+            if (files.length === 0) {
+                return makeErrorResponse(`No bundled migration files found at ${MIGRATIONS_DIR}. Package install may be corrupted.`);
+            }
+            const blocks = files.map((f) => `-- ===== ${f} =====\n${readFileSync(join(MIGRATIONS_DIR, f), 'utf-8').trimEnd()}\n`);
+            const sql = [
+                ...blocks,
+                '-- ===== Reload PostgREST schema cache =====',
+                "-- Without this, PostgREST keeps serving stale cache and knowledge_* calls fail.",
+                "NOTIFY pgrst, 'reload schema';",
+                '',
+            ].join('\n');
+            // Supabase URL format: https://<ref>.supabase.co. The SQL Editor URL is
+            // https://supabase.com/dashboard/project/<ref>/sql/new. We try to extract
+            // the ref; if the URL doesn't match the expected format (self-hosted,
+            // etc.), we fall back to the generic dashboard.
+            const supabaseUrl = adapter.supabaseUrl || '';
+            const refMatch = supabaseUrl.match(/https?:\/\/([a-z0-9]+)\.supabase\.co/);
+            const sqlEditorUrl = refMatch
+                ? `https://supabase.com/dashboard/project/${refMatch[1]}/sql/new`
+                : 'https://supabase.com/dashboard/project/_/sql/new';
+            return makeToolResponse({
+                backend: 'supabase',
+                migrations_path: MIGRATIONS_DIR,
+                files_count: files.length,
+                files,
+                sql,
+                sql_editor_url: sqlEditorUrl,
+                instructions: [
+                    `1. Open ${sqlEditorUrl}`,
+                    '2. Paste the contents of the `sql` field above into the editor.',
+                    '3. Run.',
+                    '4. Verify with setup_migrate (it should report 0 missing collections).',
+                ],
+            });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : 'unknown';
+            console.error('[setup_bootstrap] Error:', err);
+            return makeErrorResponse(`Failed to assemble bootstrap SQL from ${MIGRATIONS_DIR}: ${msg}`);
+        }
+    });
+}
+//# sourceMappingURL=setup-bootstrap.js.map

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'));
 });