@pol-studios/powersync 1.0.10 → 1.0.12

package/dist/generator/cli.js

@@ -0,0 +1,719 @@
+#!/usr/bin/env node
+
+// src/generator/cli.ts
+import { Command } from "commander";
+import * as path2 from "path";
+import * as fs2 from "fs";
+import pc from "picocolors";
+
+// src/generator/generator.ts
+import * as fs from "fs";
+import * as path from "path";
+
+// src/generator/config.ts
+var DEFAULT_SKIP_COLUMNS = [
+  "id",
+  // PowerSync handles id automatically
+  // Legacy numeric ID columns - typically not needed after UUID migration
+  "legacyId"
+];
+var DEFAULT_DECIMAL_PATTERNS = [
+  "hours",
+  "watts",
+  "voltage",
+  "rate",
+  "amount",
+  "price",
+  "cost",
+  "total"
+];
+var DEFAULT_INDEX_PATTERNS = [
+  "Id$",
+  // FK columns ending in Id (e.g., projectId, userId)
+  "^createdAt$",
+  "^updatedAt$",
+  "^status$",
+  "^type$"
+];
+
+// src/generator/parser.ts
+function parseRowType(tableContent, options) {
+  const columns = /* @__PURE__ */ new Map();
+  const rowMatch = tableContent.match(/Row:\s*\{([^}]+(?:\{[^}]*\}[^}]*)*)\}/s);
+  if (!rowMatch) return columns;
+  const rowContent = rowMatch[1];
+  const includePrimaryKey = options.syncPrimaryKey ?? options.includeId ?? false;
+  const columnRegex = /(\w+)\??:\s*([^,\n]+)/g;
+  let match;
+  while ((match = columnRegex.exec(rowContent)) !== null) {
+    const [, columnName, columnType] = match;
+    const shouldSkip = options.skipColumns.has(columnName) && !(includePrimaryKey && columnName === "id");
+    if (!shouldSkip) {
+      columns.set(columnName, columnType.trim());
+    }
+  }
+  return columns;
+}
+function extractTableDef(content, tableName, schema) {
+  const schemaRegex = new RegExp(
+    `${schema}:\\s*\\{[\\s\\S]*?Tables:\\s*\\{`,
+    "g"
+  );
+  const schemaMatch = schemaRegex.exec(content);
+  if (!schemaMatch) return null;
+  const startIndex = schemaMatch.index;
+  const tableRegex = new RegExp(
+    `(?<![A-Za-z])${tableName}:\\s*\\{[\\s\\S]*?Row:\\s*\\{[\\s\\S]*?\\}[\\s\\S]*?Relationships:\\s*\\[[^\\]]*\\]\\s*\\}`,
+    "g"
+  );
+  const searchContent = content.slice(startIndex);
+  const tableMatch = tableRegex.exec(searchContent);
+  return tableMatch ? tableMatch[0] : null;
+}
+function parseTypesFile(content, tables, skipColumns) {
+  const parsedTables = [];
+  for (const tableConfig of tables) {
+    const { name, schema = "public", syncPrimaryKey, includeId } = tableConfig;
+    const tableDef = extractTableDef(content, name, schema);
+    if (!tableDef) {
+      continue;
+    }
+    const columns = parseRowType(tableDef, {
+      skipColumns,
+      syncPrimaryKey,
+      includeId
+    });
+    if (columns.size > 0) {
+      parsedTables.push({
+        name,
+        schema,
+        columns,
+        config: tableConfig
+      });
+    }
+  }
+  return parsedTables;
+}
+
+// src/generator/templates.ts
+function toSnakeCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase();
+}
+function generateIndexDefinitions(tableName, columns, indexPatterns, additionalColumns = []) {
+  const indexes = [];
+  const snakeTableName = toSnakeCase(tableName);
+  const columnsToIndex = /* @__PURE__ */ new Set();
+  for (const column of columns) {
+    if (column === "id") continue;
+    for (const pattern of indexPatterns) {
+      const regex = new RegExp(pattern);
+      if (regex.test(column)) {
+        columnsToIndex.add(column);
+        break;
+      }
+    }
+  }
+  for (const column of additionalColumns) {
+    if (columns.includes(column) && column !== "id") {
+      columnsToIndex.add(column);
+    }
+  }
+  for (const column of columnsToIndex) {
+    const snakeColumn = toSnakeCase(column);
+    indexes.push({
+      name: `idx_${snakeTableName}_${snakeColumn}`,
+      columns: [column]
+    });
+  }
+  indexes.sort((a, b) => a.name.localeCompare(b.name));
+  return indexes;
+}
+function generateHeader(typesPath) {
+  return `/**
+ * PowerSync Schema Definition
+ *
+ * AUTO-GENERATED from ${typesPath}
+ * Run: npx @pol-studios/powersync generate-schema
+ *
+ * DO NOT EDIT MANUALLY - changes will be overwritten
+ */
+
+import { column, Schema, Table } from "@powersync/react-native";
+`;
+}
+function formatIndexes(indexes) {
+  if (indexes.length === 0) return "";
+  const indexLines = indexes.map((idx) => {
+    const columnsStr = idx.columns.map((c) => `'${c}'`).join(", ");
+    return `    { name: '${idx.name}', columns: [${columnsStr}] },`;
+  });
+  return `indexes: [
+${indexLines.join("\n")}
+  ]`;
+}
+function generateTableDefinition(table, columnDefs, indexes = []) {
+  if (columnDefs.length === 0) {
+    return `// ${table.name} - no syncable columns found`;
+  }
+  const optionsParts = [];
+  if (table.config.trackMetadata) {
+    optionsParts.push("trackMetadata: true");
+  }
+  if (indexes.length > 0) {
+    optionsParts.push(formatIndexes(indexes));
+  }
+  const optionsStr = optionsParts.length > 0 ? `, {
+  ${optionsParts.join(",\n  ")}
+}` : "";
+  return `const ${table.name} = new Table({
+${columnDefs.join("\n")}
+}${optionsStr});`;
+}
+function generateSchemaExport(tableNames) {
+  return `// ============================================================================
+// SCHEMA EXPORT
+// ============================================================================
+
+// NOTE: photo_attachments is NOT included here.
+// The AttachmentQueue from @powersync/attachments creates and manages
+// its own internal SQLite table (not a view) during queue.init().
+// This allows INSERT/UPDATE operations to work correctly.
+
+export const AppSchema = new Schema({
+${tableNames.map((name) => `  ${name},`).join("\n")}
+});
+
+export type Database = (typeof AppSchema)["types"];`;
+}
+function generateSchemaMapping(tables, schemas) {
+  const schemaGroups = /* @__PURE__ */ new Map();
+  for (const schema of schemas) {
+    if (schema !== "public") {
+      schemaGroups.set(schema, []);
+    }
+  }
+  for (const table of tables) {
+    if (table.schema !== "public" && schemaGroups.has(table.schema)) {
+      schemaGroups.get(table.schema).push(table.name);
+    }
+  }
+  const sections = [
+    `// ============================================================================
+// SCHEMA MAPPING FOR CONNECTOR
+// ============================================================================`
+  ];
+  for (const [schema, tableNames] of schemaGroups) {
+    if (tableNames.length > 0) {
+      const constName = `${schema.toUpperCase()}_SCHEMA_TABLES`;
+      sections.push(`
+// Tables in the '${schema}' schema (need .schema('${schema}') in Supabase queries)
+export const ${constName} = new Set([
+${tableNames.map((name) => `  "${name}",`).join("\n")}
+]);`);
+    }
+  }
+  const schemaChecks = Array.from(schemaGroups.entries()).filter(([, names]) => names.length > 0).map(([schema]) => {
+    const constName = `${schema.toUpperCase()}_SCHEMA_TABLES`;
+    return `  if (${constName}.has(tableName)) return "${schema}";`;
+  });
+  if (schemaChecks.length > 0) {
+    sections.push(`
+/**
+ * Get the Supabase schema for a table
+ */
+export function getTableSchema(tableName: string): ${schemas.map((s) => `"${s}"`).join(" | ")} {
+${schemaChecks.join("\n")}
+  return "public";
+}`);
+  } else {
+    sections.push(`
+/**
+ * Get the Supabase schema for a table
+ */
+export function getTableSchema(tableName: string): "public" {
+  return "public";
+}`);
+  }
+  return sections.join("\n");
+}
+function generateFKUtility() {
+  return `
+// ============================================================================
+// FOREIGN KEY UTILITIES
+// ============================================================================
+
+/**
+ * Check if a column name represents a foreign key reference
+ * Convention: columns ending in 'Id' are foreign keys (e.g., projectId -> Project table)
+ */
+export function isForeignKeyColumn(columnName: string): boolean {
+  return columnName.endsWith('Id') && columnName !== 'id';
+}
+
+/**
+ * Get the referenced table name from a foreign key column
+ * e.g., 'projectId' -> 'Project', 'equipmentFixtureUnitId' -> 'EquipmentFixtureUnit'
+ */
+export function getForeignKeyTable(columnName: string): string | null {
+  if (!isForeignKeyColumn(columnName)) return null;
+  // Remove 'Id' suffix and capitalize first letter
+  const baseName = columnName.slice(0, -2);
+  return baseName.charAt(0).toUpperCase() + baseName.slice(1);
+}`;
+}
+function generateOutputFile(tables, tableDefs, schemas, typesPath) {
+  const tableNames = tables.map((t) => t.name);
+  return `${generateHeader(typesPath)}
+
+// ============================================================================
+// TABLE DEFINITIONS
+// ============================================================================
+
+${tableDefs.join("\n\n")}
+
+${generateSchemaExport(tableNames)}
+
+${generateSchemaMapping(tables, ["public", ...schemas.filter((s) => s !== "public")])}
+${generateFKUtility()}
+`;
+}
+
+// src/generator/fk-dependencies.ts
+function fkColumnToTableName(columnName) {
+  if (!columnName.endsWith("Id") || columnName === "id") {
+    return null;
+  }
+  const baseName = columnName.slice(0, -2);
+  return baseName.charAt(0).toUpperCase() + baseName.slice(1);
+}
+function detectFKDependencies(tables) {
+  const tableNames = new Set(tables.map((t) => t.name));
+  const dependencies = /* @__PURE__ */ new Map();
+  const dependents = /* @__PURE__ */ new Map();
+  const fkRelationships = [];
+  for (const table of tables) {
+    dependencies.set(table.name, []);
+    dependents.set(table.name, []);
+  }
+  for (const table of tables) {
+    for (const [columnName] of table.columns) {
+      const referencedTable = fkColumnToTableName(columnName);
+      if (referencedTable && tableNames.has(referencedTable)) {
+        const tableDeps = dependencies.get(table.name) || [];
+        if (!tableDeps.includes(referencedTable)) {
+          tableDeps.push(referencedTable);
+          dependencies.set(table.name, tableDeps);
+        }
+        const refDeps = dependents.get(referencedTable) || [];
+        if (!refDeps.includes(table.name)) {
+          refDeps.push(table.name);
+          dependents.set(referencedTable, refDeps);
+        }
+        fkRelationships.push({
+          table: table.name,
+          column: columnName,
+          referencedTable
+        });
+      }
+    }
+  }
+  const uploadOrder = getUploadOrder({ dependencies });
+  return {
+    dependencies,
+    dependents,
+    uploadOrder,
+    fkRelationships
+  };
+}
+function getUploadOrder(graph) {
+  const result = [];
+  const inDegree = /* @__PURE__ */ new Map();
+  const adjList = /* @__PURE__ */ new Map();
+  for (const [table, deps] of graph.dependencies) {
+    inDegree.set(table, deps.length);
+    adjList.set(table, []);
+  }
+  for (const [table, deps] of graph.dependencies) {
+    for (const dep of deps) {
+      const list = adjList.get(dep) || [];
+      list.push(table);
+      adjList.set(dep, list);
+    }
+  }
+  const queue = [];
+  for (const [table, degree] of inDegree) {
+    if (degree === 0) {
+      queue.push(table);
+    }
+  }
+  queue.sort();
+  while (queue.length > 0) {
+    const table = queue.shift();
+    result.push(table);
+    const dependentTables = adjList.get(table) || [];
+    for (const dependent of dependentTables) {
+      const newDegree = (inDegree.get(dependent) || 0) - 1;
+      inDegree.set(dependent, newDegree);
+      if (newDegree === 0) {
+        queue.push(dependent);
+        queue.sort();
+      }
+    }
+  }
+  if (result.length < graph.dependencies.size) {
+    const remaining = [...graph.dependencies.keys()].filter((t) => !result.includes(t)).sort();
+    result.push(...remaining);
+  }
+  return result;
+}
+
+// src/generator/generator.ts
+function mapTypeToPowerSync(tsType, columnName, decimalPatterns) {
+  const cleanType = tsType.trim().replace(/\s*\|\s*null/g, "");
+  if (cleanType.includes("Json") || cleanType.includes("unknown") || cleanType.includes("{")) {
+    return null;
+  }
+  if (cleanType.includes("[]")) {
+    return null;
+  }
+  if (cleanType === "boolean") {
+    return { type: "column.integer", isBoolean: true };
+  }
+  if (cleanType === "number") {
+    if (decimalPatterns.some(
+      (pattern) => columnName.toLowerCase().includes(pattern.toLowerCase())
+    )) {
+      return { type: "column.real" };
+    }
+    return { type: "column.integer" };
+  }
+  if (cleanType === "string") {
+    return { type: "column.text" };
+  }
+  if (cleanType.includes("Database[") && cleanType.includes("Enums")) {
+    return { type: "column.text", isEnum: true };
+  }
+  return { type: "column.text" };
+}
+function generateColumnDefs(table, decimalPatterns) {
+  const columnDefs = [];
+  for (const [columnName, tsType] of table.columns) {
+    const mapping = mapTypeToPowerSync(tsType, columnName, decimalPatterns);
+    if (mapping) {
+      let comment = "";
+      if (mapping.isBoolean) {
+        comment = " // boolean stored as 0/1";
+      } else if (mapping.isEnum) {
+        comment = " // enum stored as text";
+      }
+      columnDefs.push(`  ${columnName}: ${mapping.type},${comment}`);
+    }
+  }
+  return columnDefs;
+}
+async function generateSchema(config, options) {
+  const cwd = options?.cwd ?? process.cwd();
+  const verbose = options?.verbose ?? false;
+  const dryRun = options?.dryRun ?? false;
+  const result = {
+    success: false,
+    tablesGenerated: 0,
+    outputPath: "",
+    errors: [],
+    warnings: []
+  };
+  const typesPath = path.isAbsolute(config.typesPath) ? config.typesPath : path.resolve(cwd, config.typesPath);
+  const outputPath = path.isAbsolute(config.outputPath) ? config.outputPath : path.resolve(cwd, config.outputPath);
+  result.outputPath = outputPath;
+  if (!fs.existsSync(typesPath)) {
+    result.errors.push(`Types file not found: ${typesPath}`);
+    return result;
+  }
+  if (verbose) {
+    console.log(`Reading types from: ${typesPath}`);
+  }
+  const typesContent = fs.readFileSync(typesPath, "utf-8");
+  const skipColumns = /* @__PURE__ */ new Set([
+    ...DEFAULT_SKIP_COLUMNS,
+    ...config.skipColumns ?? []
+  ]);
+  const decimalPatterns = [
+    ...DEFAULT_DECIMAL_PATTERNS,
+    ...config.decimalPatterns ?? []
+  ];
+  const parsedTables = parseTypesFile(
+    typesContent,
+    config.tables,
+    skipColumns
+  );
+  for (const tableConfig of config.tables) {
+    const found = parsedTables.some((t) => t.name === tableConfig.name);
+    if (!found) {
+      result.warnings.push(
+        `Table '${tableConfig.name}' not found in schema '${tableConfig.schema ?? "public"}'`
+      );
+    }
+  }
+  if (parsedTables.length === 0) {
+    result.errors.push("No tables were parsed successfully");
+    return result;
+  }
+  const autoIndexes = config.autoIndexes ?? true;
+  const indexPatterns = autoIndexes ? [...DEFAULT_INDEX_PATTERNS, ...config.indexPatterns ?? []] : config.indexPatterns ?? [];
+  const indexColumns = config.indexColumns ?? [];
+  const dependencyGraph = detectFKDependencies(parsedTables);
+  result.dependencyGraph = dependencyGraph;
+  if (verbose && dependencyGraph.fkRelationships.length > 0) {
+    console.log(`
+FK Dependencies detected: ${dependencyGraph.fkRelationships.length}`);
+    for (const fk of dependencyGraph.fkRelationships) {
+      console.log(`  ${fk.table}.${fk.column} -> ${fk.referencedTable}`);
+    }
+    console.log(`
+Recommended upload order:`);
+    dependencyGraph.uploadOrder.forEach((table, i) => {
+      console.log(`  ${i + 1}. ${table}`);
+    });
+    console.log("");
+  }
+  const tableDefs = [];
+  let totalIndexes = 0;
+  for (const table of parsedTables) {
+    if (verbose) {
+      const syncPK = table.config.syncPrimaryKey || table.config.includeId;
+      console.log(
+        `Processing ${table.schema}.${table.name} (${table.columns.size} columns)${table.config.trackMetadata ? " [trackMetadata]" : ""}${syncPK ? " [syncPrimaryKey]" : ""}`
+      );
+    }
+    const columnDefs = generateColumnDefs(table, decimalPatterns);
+    if (columnDefs.length === 0) {
+      result.warnings.push(`Table '${table.name}' has no syncable columns`);
+      continue;
+    }
+    const columnNames = [...table.columns.keys()];
+    const indexes = indexPatterns.length > 0 || indexColumns.length > 0 ? generateIndexDefinitions(table.name, columnNames, indexPatterns, indexColumns) : [];
+    totalIndexes += indexes.length;
+    if (verbose && indexes.length > 0) {
+      console.log(`  Indexes: ${indexes.map((i) => i.name).join(", ")}`);
+    }
+    tableDefs.push(generateTableDefinition(table, columnDefs, indexes));
+  }
+  result.indexesGenerated = totalIndexes;
+  const schemas = [...new Set(config.tables.map((t) => t.schema ?? "public"))];
+  const relativePath = path.relative(cwd, typesPath);
+  const output = generateOutputFile(
+    parsedTables.filter(
+      (t) => tableDefs.some((def) => def.includes(`const ${t.name} =`))
+    ),
+    tableDefs,
+    schemas,
+    relativePath
+  );
+  if (dryRun) {
+    result.success = true;
+    result.tablesGenerated = tableDefs.length;
+    result.output = output;
+    return result;
+  }
+  const outputDir = path.dirname(outputPath);
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+  fs.writeFileSync(outputPath, output);
+  result.success = true;
+  result.tablesGenerated = tableDefs.length;
+  return result;
+}
+
+// src/generator/cli.ts
+var program = new Command();
+var VERSION = "1.0.0";
+program.name("@pol-studios/powersync").description("PowerSync utilities for offline-first applications").version(VERSION);
+program.command("generate-schema").description("Generate PowerSync schema from database.types.ts").option(
+  "-c, --config <path>",
+  "Path to config file",
+  "powersync.config.ts"
+).option("-v, --verbose", "Enable verbose output", false).option("-d, --dry-run", "Preview output without writing files", false).option("-w, --watch", "Watch for changes and regenerate", false).action(async (options) => {
+  const cwd = process.cwd();
+  console.log(pc.bold(pc.cyan("\n  PowerSync Schema Generator\n")));
+  const configPath = path2.isAbsolute(options.config) ? options.config : path2.resolve(cwd, options.config);
+  if (!fs2.existsSync(configPath)) {
+    console.error(pc.red(`  Error: Config file not found: ${configPath}`));
+    console.log(pc.dim(`
+  Create a powersync.config.ts file in your project root:
+
+  ${pc.cyan(`import { defineConfig } from '@pol-studios/powersync/generator';
+
+  export default defineConfig({
+    typesPath: './database.types.ts',
+    outputPath: './src/data/powersync-schema.ts',
+    tables: [
+      { name: 'User', schema: 'public' },
+      { name: 'Post', schema: 'public', trackMetadata: true },
+    ],
+  });`)}
+`));
+    process.exit(1);
+  }
+  let config;
+  try {
+    console.log(pc.dim(`  Loading config from: ${configPath}`));
+    const configModule = await import(configPath);
+    config = configModule.default;
+    if (!config || !config.tables || !config.typesPath || !config.outputPath) {
+      throw new Error(
+        "Invalid config: must export { typesPath, outputPath, tables }"
+      );
+    }
+  } catch (error) {
+    console.error(pc.red(`  Error loading config: ${error}`));
+    console.log(pc.dim(`
+  Make sure your config file:
+  1. Uses 'export default defineConfig({...})'
+  2. Contains typesPath, outputPath, and tables properties
+  3. Can be imported (run with tsx or ts-node if using TypeScript)
+`));
+    process.exit(1);
+  }
+  const runGeneration = async () => {
+    console.log(pc.dim(`  Types file:  ${config.typesPath}`));
+    console.log(pc.dim(`  Output file: ${config.outputPath}`));
+    console.log(pc.dim(`  Tables:      ${config.tables.length}`));
+    if (options.dryRun) {
+      console.log(pc.cyan("  Mode:        dry-run (no files will be written)"));
+    }
+    console.log("");
+    const result = await generateSchema(config, {
+      cwd,
+      verbose: options.verbose,
+      dryRun: options.dryRun
+    });
+    if (result.warnings.length > 0) {
+      console.log(pc.yellow("  Warnings:"));
+      for (const warning of result.warnings) {
+        console.log(pc.yellow(`    - ${warning}`));
+      }
+      console.log("");
+    }
+    if (result.errors.length > 0) {
+      console.log(pc.red("  Errors:"));
+      for (const error of result.errors) {
+        console.log(pc.red(`    - ${error}`));
+      }
+      console.log("");
+    }
+    if (result.success) {
+      if (options.dryRun) {
+        console.log(
+          pc.cyan(`  ${pc.bold("Dry run:")} Would generate ${result.tablesGenerated} tables`)
+        );
+        if (result.indexesGenerated !== void 0 && result.indexesGenerated > 0) {
+          console.log(pc.cyan(`  Indexes: ${result.indexesGenerated}`));
+        }
+        if (options.verbose && result.output) {
+          console.log(pc.dim("\n  Generated output:\n"));
+          console.log(pc.dim(result.output.split("\n").map((l) => "    " + l).join("\n")));
+        }
+      } else {
+        console.log(
+          pc.green(`  ${pc.bold("Success!")} Generated ${result.tablesGenerated} tables`)
+        );
+        if (result.indexesGenerated !== void 0 && result.indexesGenerated > 0) {
+          console.log(pc.green(`  Indexes: ${result.indexesGenerated}`));
+        }
+        if (result.dependencyGraph && result.dependencyGraph.fkRelationships.length > 0) {
+          console.log(pc.green(`  FK dependencies: ${result.dependencyGraph.fkRelationships.length}`));
+        }
+        console.log(pc.dim(`  Output: ${result.outputPath}`));
+      }
+      console.log("");
+    } else {
+      console.error(pc.red("  Schema generation failed"));
+      if (!options.watch) {
+        process.exit(1);
+      }
+    }
+    return result;
+  };
+  await runGeneration();
+  if (options.watch) {
+    const typesPath = path2.isAbsolute(config.typesPath) ? config.typesPath : path2.resolve(cwd, config.typesPath);
+    console.log(pc.cyan(`  Watching for changes: ${typesPath}`));
+    console.log(pc.dim("  Press Ctrl+C to stop\n"));
+    fs2.watchFile(typesPath, { interval: 1e3 }, async (curr, prev) => {
+      if (curr.mtime !== prev.mtime) {
+        console.log(pc.cyan("\n  File changed, regenerating...\n"));
+        await runGeneration();
+      }
+    });
+    process.on("SIGINT", () => {
+      fs2.unwatchFile(typesPath);
+      console.log(pc.dim("\n  Stopped watching"));
+      process.exit(0);
+    });
+  }
+});
+program.command("init").description("Create a powersync.config.ts template").option("-f, --force", "Overwrite existing config file", false).action((options) => {
+  const cwd = process.cwd();
+  const configPath = path2.resolve(cwd, "powersync.config.ts");
+  if (fs2.existsSync(configPath) && !options.force) {
+    console.error(
+      pc.red(`  Config file already exists: ${configPath}`)
+    );
+    console.log(pc.dim("  Use --force to overwrite"));
+    process.exit(1);
+  }
+  const template = `import { defineConfig } from '@pol-studios/powersync/generator';
+
+export default defineConfig({
+  // Path to Supabase-generated types
+  typesPath: './database.types.ts',
+
+  // Output path for generated schema
+  outputPath: './src/data/powersync-schema.ts',
+
+  // Tables to sync
+  tables: [
+    // Public schema tables (default)
+    { name: 'User' },
+    { name: 'Post', trackMetadata: true },
+
+    // Tables in other schemas
+    // { name: 'Profile', schema: 'core' },
+
+    // For tables with integer PKs referenced by FKs in other tables,
+    // use syncPrimaryKey: true to include the id column
+    // { name: 'Group', schema: 'core', syncPrimaryKey: true },
+
+    // Access control tables (required for offline auth)
+    // { name: 'UserAccess', schema: 'core' },
+    // { name: 'UserGroup', schema: 'core' },
+    // { name: 'GroupAccessKey', schema: 'core', syncPrimaryKey: true },
+    // { name: 'Group', schema: 'core', syncPrimaryKey: true },
+  ],
+
+  // Optional: columns to always skip
+  // skipColumns: ['searchVector', 'tsv'],
+
+  // Optional: column name patterns for decimal values (use column.real)
+  // decimalPatterns: ['price', 'amount', 'rate'],
+
+  // Auto-generate indexes for FK columns and common patterns (default: true)
+  // autoIndexes: true,
+
+  // Additional columns to index (exact names)
+  // indexColumns: ['name', 'email'],
+
+  // Additional index patterns (regex, in addition to defaults: Id$, createdAt, updatedAt, status, type)
+  // indexPatterns: ['^sortOrder$'],
+});
+`;
+  fs2.writeFileSync(configPath, template);
+  console.log(pc.green(`  Created config file: ${configPath}`));
+  console.log(pc.dim(`
+  Next steps:
+  1. Edit powersync.config.ts with your tables
+  2. Run: npx @pol-studios/powersync generate-schema
+`));
+});
+program.parse();