@pol-studios/powersync 1.0.10 → 1.0.12

package/dist/generator/index.js

@@ -0,0 +1,590 @@
+// src/generator/config.ts
+function defineConfig(config) {
+  return config;
+}
+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/generator.ts
+import * as fs from "fs";
+import * as path from "path";
+
+// 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;
+}
+function getAvailableSchemas(content) {
+  const schemas = [];
+  const schemaRegex = /(\w+):\s*\{[\s\S]*?Tables:\s*\{/g;
+  let match;
+  while ((match = schemaRegex.exec(content)) !== null) {
+    schemas.push(match[1]);
+  }
+  return schemas;
+}
+function getTablesInSchema(content, schema) {
+  const tables = [];
+  const schemaRegex = new RegExp(`${schema}:\\s*\\{[\\s\\S]*?Tables:\\s*\\{([\\s\\S]*?)\\}\\s*Views:`, "g");
+  const schemaMatch = schemaRegex.exec(content);
+  if (!schemaMatch) return tables;
+  const tablesContent = schemaMatch[1];
+  const tableNameRegex = /^\s*(\w+):\s*\{/gm;
+  let match;
+  while ((match = tableNameRegex.exec(tablesContent)) !== null) {
+    tables.push(match[1]);
+  }
+  return tables;
+}
+
+// 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;
+}
+function getRootTables(graph) {
+  const roots = [];
+  for (const [table, deps] of graph.dependencies) {
+    if (deps.length === 0) {
+      roots.push(table);
+    }
+  }
+  return roots.sort();
+}
+function getLeafTables(graph) {
+  const leaves = [];
+  for (const [table, deps] of graph.dependents) {
+    if (deps.length === 0) {
+      leaves.push(table);
+    }
+  }
+  return leaves.sort();
+}
+function formatDependencyGraph(graph) {
+  const lines = [];
+  lines.push("FK Dependencies:");
+  for (const fk of graph.fkRelationships) {
+    lines.push(`  ${fk.table}.${fk.column} -> ${fk.referencedTable}`);
+  }
+  if (graph.fkRelationships.length === 0) {
+    lines.push("  (none detected)");
+  }
+  lines.push("");
+  lines.push("Upload Order (topological):");
+  graph.uploadOrder.forEach((table, i) => {
+    const deps = graph.dependencies.get(table) || [];
+    const depStr = deps.length > 0 ? ` (depends on: ${deps.join(", ")})` : " (root)";
+    lines.push(`  ${i + 1}. ${table}${depStr}`);
+  });
+  return lines.join("\n");
+}
+
+// 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;
+}
+export {
+  DEFAULT_DECIMAL_PATTERNS,
+  DEFAULT_INDEX_PATTERNS,
+  DEFAULT_SKIP_COLUMNS,
+  defineConfig,
+  detectFKDependencies,
+  extractTableDef,
+  fkColumnToTableName,
+  formatDependencyGraph,
+  generateColumnDefs,
+  generateFKUtility,
+  generateHeader,
+  generateIndexDefinitions,
+  generateOutputFile,
+  generateSchema,
+  generateSchemaExport,
+  generateSchemaMapping,
+  generateTableDefinition,
+  getAvailableSchemas,
+  getLeafTables,
+  getRootTables,
+  getTablesInSchema,
+  getUploadOrder,
+  mapTypeToPowerSync,
+  parseRowType,
+  parseTypesFile
+};
+//# sourceMappingURL=index.js.map