{"version":3,"sources":["../src/schema-sql.ts","../src/schema-migrate.ts","../src/schema-tables.ts","../src/hmr.ts","../src/openapi/scalar-component.tsx","../src/openapi/docs-route.tsx"],"sourcesContent":["import type { FarmSchema, FarmSchemaField, FarmSchemaModel } from \"./schema\";\n\nexport type FarmSqlDialect = \"postgres\" | \"mysql\" | \"sqlite\";\n\nexport type ResolvedSchemaField = FarmSchemaField & {\n  name: string;\n};\n\nexport type ResolvedSchemaModel = Omit<FarmSchemaModel, \"fields\"> & {\n  name: string;\n  fields: Record<string, ResolvedSchemaField>;\n};\n\nexport type CollectedSchemaModel = {\n  /** Namespace that owns the model: an integration key or a plugin name. */\n  ownerKey: string;\n  modelKey: string;\n  modelName: string;\n  exportName: string;\n  prismaModelName: string;\n  model: ResolvedSchemaModel;\n};\n\n/**\n * Resolve a schema's extensions, overrides, and name mappings.\n *\n * Table and column names fall back to the schema's own keys, which is what the\n * runtime orm uses (`createIntegrationOrm` reads `model.name ?? modelKey`). Any\n * other default would generate artifacts describing tables the app cannot\n * actually read.\n */\nexport function resolveSchemaModels(\n  ownerKey: string,\n  schema: FarmSchema,\n): Record<string, ResolvedSchemaModel> {\n  const models: Record<string, FarmSchemaModel> = Object.fromEntries(\n    Object.entries(schema.models).map(([modelKey, model]) => [modelKey, cloneSchemaModel(model)]),\n  );\n\n  for (const [modelKey, extension] of Object.entries(schema.extend || {})) {\n    const existing = models[modelKey];\n    models[modelKey] = {\n      ...(existing || { fields: {} }),\n      ...(extension.name ? { name: extension.name } : {}),\n      ...(extension.description ? { description: extension.description } : {}),\n      fields: {\n        ...existing?.fields,\n        ...extension.fields,\n      },\n      constraints: [...(existing?.constraints || []), ...(extension.constraints || [])],\n      meta: {\n        ...existing?.meta,\n        ...extension.meta,\n      },\n    };\n  }\n\n  for (const [modelKey, override] of Object.entries(schema.override || {})) {\n    const existing = models[modelKey];\n\n    if (!existing) {\n      throw new Error(\n        `Schema override for \"${ownerKey}.${modelKey}\" is invalid because that model does not exist.`,\n      );\n    }\n\n    const fields = {\n      ...existing.fields,\n    };\n\n    for (const [fieldKey, fieldOverride] of Object.entries(override.fields || {})) {\n      const existingField = fields[fieldKey];\n\n      if (!existingField && !fieldOverride.type) {\n        throw new Error(\n          `Schema override for \"${ownerKey}.${modelKey}.${fieldKey}\" is missing a field type.`,\n        );\n      }\n\n      fields[fieldKey] = {\n        ...existingField,\n        ...fieldOverride,\n      } as FarmSchemaField;\n    }\n\n    models[modelKey] = {\n      ...existing,\n      ...(override.name ? { name: override.name } : {}),\n      ...(override.description ? { description: override.description } : {}),\n      fields,\n      constraints: override.constraints || existing.constraints,\n      meta: {\n        ...existing.meta,\n        ...override.meta,\n      },\n    };\n  }\n\n  const resolvedModels: Record<string, ResolvedSchemaModel> = {};\n\n  for (const [modelKey, model] of Object.entries(models)) {\n    const modelName = model.name || modelKey;\n    const fieldNames = new Set<string>();\n    const resolvedFields: Record<string, ResolvedSchemaField> = {};\n\n    for (const [fieldKey, field] of Object.entries(model.fields)) {\n      const fieldName = field.name || fieldKey;\n\n      if (fieldNames.has(fieldName)) {\n        throw new Error(\n          `Schema model \"${ownerKey}.${modelKey}\" contains duplicate field name \"${fieldName}\".`,\n        );\n      }\n\n      fieldNames.add(fieldName);\n      resolvedFields[fieldKey] = {\n        ...field,\n        name: fieldName,\n      };\n    }\n\n    resolvedModels[modelKey] = {\n      ...model,\n      name: modelName,\n      fields: resolvedFields,\n    };\n  }\n\n  return resolvedModels;\n}\n\nfunction cloneSchemaModel(model: FarmSchemaModel): FarmSchemaModel {\n  return {\n    ...model,\n    fields: Object.fromEntries(\n      Object.entries(model.fields).map(([fieldKey, field]) => [fieldKey, { ...field }]),\n    ),\n    constraints: model.constraints ? [...model.constraints] : undefined,\n    meta: model.meta ? { ...model.meta } : undefined,\n  };\n}\n\n/**\n * Flatten owners' schemas into one list, rejecting two models that would\n * resolve to the same table.\n *\n * `only` narrows an owner to the models it actually controls; an owner handed a\n * schema it shares with the rest of the app should not claim all of it.\n */\nexport function collectSchemaModels(\n  entries: ReadonlyArray<readonly [string, FarmSchema, (readonly string[])?]>,\n): CollectedSchemaModel[] {\n  const collectedModels: CollectedSchemaModel[] = [];\n  const seenModelNames = new Map<string, string>();\n\n  for (const [ownerKey, schema, only] of entries) {\n    const resolvedModels = resolveSchemaModels(ownerKey, schema);\n\n    for (const [modelKey, model] of Object.entries(resolvedModels)) {\n      if (only && !only.includes(modelKey)) continue;\n\n      const collisionKey = model.name.toLowerCase();\n      const previousOwner = seenModelNames.get(collisionKey);\n\n      if (previousOwner && previousOwner !== `${ownerKey}.${modelKey}`) {\n        throw new Error(\n          `Schema model \"${ownerKey}.${modelKey}\" resolves to \"${model.name}\", which conflicts with \"${previousOwner}\". Rename one of the models with schema.models.<model>.name.`,\n        );\n      }\n\n      seenModelNames.set(collisionKey, `${ownerKey}.${modelKey}`);\n\n      collectedModels.push({\n        ownerKey,\n        modelKey,\n        modelName: model.name,\n        exportName: toCamelCase(`${ownerKey}_${modelKey}`),\n        prismaModelName: toPascalCase(`${ownerKey}_${modelKey}`),\n        model,\n      });\n    }\n  }\n\n  return collectedModels;\n}\n\nexport type FarmSqlStatement = {\n  kind: \"table\" | \"index\";\n  /** The object this statement creates, for drift reporting. */\n  target: string;\n  sql: string;\n};\n\n/**\n * Emit create statements for a set of models.\n *\n * Everything here is derivable from the schema: nothing is inferred from a live\n * database, so the output is stable and reviewable before it is applied.\n */\nexport function generateSqlStatements(\n  models: readonly CollectedSchemaModel[],\n  dialect: FarmSqlDialect,\n): FarmSqlStatement[] {\n  const modelLookup = createModelLookup(models);\n  const statements: FarmSqlStatement[] = [];\n\n  for (const model of models) {\n    statements.push({\n      kind: \"table\",\n      target: model.modelName,\n      sql: renderSqlTable(model, dialect, modelLookup),\n    });\n\n    for (const index of renderSqlIndexes(model, dialect)) {\n      statements.push(index);\n    }\n  }\n\n  return statements;\n}\n\n/** Render models as a standalone `.sql` file. */\nexport function renderSqlSchemaFile(\n  models: readonly CollectedSchemaModel[],\n  dialect: FarmSqlDialect,\n): string {\n  const lines = [\"-- Generated by Farm.js CLI. Review before applying.\", \"\"];\n  const modelLookup = createModelLookup(models);\n\n  for (const model of models) {\n    lines.push(\n      `-- Owner \"${model.ownerKey}\" model \"${model.modelKey}\"`,\n      renderSqlTable(model, dialect, modelLookup),\n      \"\",\n    );\n\n    for (const statement of renderSqlIndexes(model, dialect)) {\n      lines.push(statement.sql, \"\");\n    }\n  }\n\n  return lines.join(\"\\n\").trimEnd() + \"\\n\";\n}\n\nfunction renderSqlTable(\n  model: CollectedSchemaModel,\n  dialect: FarmSqlDialect,\n  modelLookup: Map<string, CollectedSchemaModel>,\n) {\n  const tableName = quoteSqlIdentifier(dialect, model.modelName);\n  const lines = [`CREATE TABLE IF NOT EXISTS ${tableName} (`];\n  const columns: string[] = [];\n  const internalReferences = createInternalReferenceLookup(model, dialect, modelLookup);\n\n  for (const [fieldKey, field] of Object.entries(model.model.fields)) {\n    const parts = [\n      `  ${quoteSqlIdentifier(dialect, field.name)}`,\n      getSqlColumnType(field, dialect),\n    ];\n\n    if (field.primaryKey) {\n      parts.push(\"PRIMARY KEY\");\n    } else if (!isNullableField(field)) {\n      parts.push(\"NOT NULL\");\n    }\n\n    if (!field.primaryKey && field.unique) {\n      parts.push(\"UNIQUE\");\n    }\n\n    const defaultValue = getSqlDefaultExpression(field, dialect);\n    if (defaultValue) {\n      parts.push(`DEFAULT ${defaultValue}`);\n    }\n\n    const reference = internalReferences.get(fieldKey);\n    if (reference) {\n      parts.push(reference);\n    } else if (field.reference) {\n      parts.push(\n        `/* references ${field.reference.model}.${field.reference.field}${field.reference.onDelete ? ` on delete ${field.reference.onDelete}` : \"\"} */`,\n      );\n    }\n\n    columns.push(parts.join(\" \"));\n  }\n\n  lines.push(columns.join(\",\\n\"));\n  lines.push(\");\");\n  return lines.join(\"\\n\");\n}\n\nfunction renderSqlIndexes(\n  model: CollectedSchemaModel,\n  dialect: FarmSqlDialect,\n): FarmSqlStatement[] {\n  const statements: FarmSqlStatement[] = [];\n  const tableName = quoteSqlIdentifier(dialect, model.modelName);\n\n  for (const field of Object.values(model.model.fields)) {\n    if (!field.index) {\n      continue;\n    }\n\n    const indexName = `${model.modelName}_${field.name}_idx`;\n    statements.push({\n      kind: \"index\",\n      target: indexName,\n      sql: `CREATE INDEX IF NOT EXISTS ${quoteSqlIdentifier(dialect, indexName)} ON ${tableName} (${quoteSqlIdentifier(dialect, field.name)});`,\n    });\n  }\n\n  for (const constraint of model.model.constraints || []) {\n    const indexName =\n      constraint.name ||\n      `${model.modelName}_${constraint.fields.map((fieldKey) => model.model.fields[fieldKey]?.name || fieldKey).join(\"_\")}_${constraint.type}`;\n    const fields = constraint.fields\n      .map((fieldKey) =>\n        quoteSqlIdentifier(dialect, model.model.fields[fieldKey]?.name || fieldKey),\n      )\n      .join(\", \");\n\n    const kind = constraint.type === \"unique\" ? \"CREATE UNIQUE INDEX\" : \"CREATE INDEX\";\n    statements.push({\n      kind: \"index\",\n      target: indexName,\n      sql: `${kind} IF NOT EXISTS ${quoteSqlIdentifier(dialect, indexName)} ON ${tableName} (${fields});`,\n    });\n  }\n\n  return statements;\n}\n\nfunction createInternalReferenceLookup(\n  model: CollectedSchemaModel,\n  dialect: FarmSqlDialect,\n  modelLookup: Map<string, CollectedSchemaModel>,\n) {\n  const lookup = new Map<string, string>();\n\n  for (const [fieldKey, field] of Object.entries(model.model.fields)) {\n    if (!field.reference) {\n      continue;\n    }\n\n    const referencedModel = modelLookup.get(`${model.ownerKey}.${field.reference.model}`);\n\n    if (referencedModel) {\n      const referencedField = field.reference.field;\n      const pieces = [\n        `REFERENCES ${quoteSqlIdentifier(dialect, referencedModel.modelName)} (${quoteSqlIdentifier(dialect, referencedModel.model.fields[referencedField]?.name || referencedField)})`,\n      ];\n\n      if (field.reference.onDelete) {\n        pieces.push(`ON DELETE ${field.reference.onDelete.toUpperCase()}`);\n      }\n\n      lookup.set(fieldKey, pieces.join(\" \"));\n    }\n  }\n\n  return lookup;\n}\n\nexport function getSqlColumnType(field: ResolvedSchemaField, dialect: FarmSqlDialect) {\n  if (dialect === \"postgres\") {\n    switch (field.type) {\n      case \"boolean\":\n        return \"BOOLEAN\";\n      case \"integer\":\n        return \"INTEGER\";\n      case \"number\":\n        return \"DOUBLE PRECISION\";\n      case \"datetime\":\n        return \"TIMESTAMPTZ\";\n      case \"json\":\n        return \"JSONB\";\n      default:\n        return \"TEXT\";\n    }\n  }\n\n  if (dialect === \"mysql\") {\n    switch (field.type) {\n      case \"boolean\":\n        return \"BOOLEAN\";\n      case \"integer\":\n        return \"INT\";\n      case \"number\":\n        return \"DOUBLE\";\n      case \"datetime\":\n        return \"DATETIME\";\n      case \"json\":\n        return \"JSON\";\n      case \"text\":\n        return \"TEXT\";\n      default:\n        return \"VARCHAR(255)\";\n    }\n  }\n\n  switch (field.type) {\n    case \"boolean\":\n    case \"integer\":\n      return \"INTEGER\";\n    case \"number\":\n      return \"REAL\";\n    default:\n      return \"TEXT\";\n  }\n}\n\nexport function getSqlDefaultExpression(field: ResolvedSchemaField, dialect: FarmSqlDialect) {\n  if (field.default === undefined) {\n    return null;\n  }\n\n  if (field.type === \"datetime\" && field.default === \"now\") {\n    return \"CURRENT_TIMESTAMP\";\n  }\n\n  if (typeof field.default === \"string\") {\n    return `'${escapeSqlString(field.default)}'`;\n  }\n\n  if (typeof field.default === \"number\") {\n    return String(field.default);\n  }\n\n  if (typeof field.default === \"boolean\") {\n    if (dialect === \"sqlite\") {\n      return field.default ? \"1\" : \"0\";\n    }\n    return field.default ? \"TRUE\" : \"FALSE\";\n  }\n\n  return null;\n}\n\nexport function isNullableField(field: ResolvedSchemaField) {\n  return field.nullable === true || field.required === false;\n}\n\nexport function quoteSqlIdentifier(dialect: FarmSqlDialect, value: string) {\n  if (dialect === \"mysql\") {\n    return `\\`${value.replace(/`/g, \"``\")}\\``;\n  }\n\n  return `\"${value.replace(/\"/g, '\"\"')}\"`;\n}\n\nfunction createModelLookup(models: readonly CollectedSchemaModel[]) {\n  return new Map(models.map((model) => [`${model.ownerKey}.${model.modelKey}`, model]));\n}\n\nexport function toSnakeCase(value: string) {\n  return value\n    .replace(/([a-z0-9])([A-Z])/g, \"$1_$2\")\n    .replace(/[\\s.-]+/g, \"_\")\n    .replace(/__+/g, \"_\")\n    .toLowerCase();\n}\n\nexport function toPascalCase(value: string) {\n  return value\n    .replace(/([a-z0-9])([A-Z])/g, \"$1 $2\")\n    .replace(/[\\s._-]+/g, \" \")\n    .split(\" \")\n    .filter(Boolean)\n    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))\n    .join(\"\");\n}\n\nexport function toCamelCase(value: string) {\n  const pascal = toPascalCase(value);\n  return pascal ? pascal.charAt(0).toLowerCase() + pascal.slice(1) : pascal;\n}\n\nexport function escapeSqlString(value: string) {\n  // Standard-conforming SQL string literal: only quote doubling; backslashes\n  // are literal characters.\n  return value.replace(/'/g, \"''\");\n}\n","import {\n  generateSqlStatements,\n  type CollectedSchemaModel,\n  type FarmSqlDialect,\n  type FarmSqlStatement,\n} from \"./schema-sql\";\n\n/** The subset of a database client this needs: run a statement, read a result. */\nexport type FarmSchemaExecutor = {\n  /** Run a statement that returns nothing. */\n  execute(sql: string): Promise<void>;\n  /** Run a query and return its rows. */\n  query(sql: string, params?: unknown[]): Promise<Record<string, unknown>[]>;\n};\n\nexport type FarmSchemaDrift = {\n  table: string;\n  /** Declared in the schema but absent from the table. */\n  missingColumns: string[];\n  /** Present in the table but not declared. Reported, never dropped. */\n  extraColumns: string[];\n};\n\nexport type FarmSchemaMigratePlan = {\n  dialect: FarmSqlDialect;\n  /** Statements for tables that do not exist yet. */\n  statements: FarmSqlStatement[];\n  /** Tables that exist and already match the schema. */\n  upToDate: string[];\n  /** Tables that exist but differ. Never altered automatically. */\n  drift: FarmSchemaDrift[];\n};\n\n/**\n * Compare resolved models against the live database and plan what to create.\n *\n * Creation is derivable from the schema alone, so it is safe to emit. Changing\n * an existing table is not: a rename and a drop-plus-add look identical here,\n * and one of them destroys data. Differences are reported for a human instead.\n */\nexport async function planSchemaMigration(\n  models: readonly CollectedSchemaModel[],\n  dialect: FarmSqlDialect,\n  executor: FarmSchemaExecutor,\n): Promise<FarmSchemaMigratePlan> {\n  const statements: FarmSqlStatement[] = [];\n  const upToDate: string[] = [];\n  const drift: FarmSchemaDrift[] = [];\n\n  // Emitted once over the whole set so cross-model references resolve, then\n  // grouped: a table statement opens a group and its indexes follow it.\n  const byTable = new Map<string, FarmSqlStatement[]>();\n  let currentTable: FarmSqlStatement[] | undefined;\n  for (const statement of generateSqlStatements(models, dialect)) {\n    if (statement.kind === \"table\") {\n      currentTable = [];\n      byTable.set(statement.target, currentTable);\n    }\n    currentTable?.push(statement);\n  }\n\n  for (const model of models) {\n    const existing = await describeTable(executor, dialect, model.modelName);\n\n    if (!existing) {\n      statements.push(...(byTable.get(model.modelName) ?? []));\n      continue;\n    }\n\n    const declared = Object.values(model.model.fields).map((field) => field.name);\n    const missingColumns = declared.filter((column) => !existing.has(column.toLowerCase()));\n    const extraColumns = [...existing].filter(\n      (column) => !declared.some((declaredColumn) => declaredColumn.toLowerCase() === column),\n    );\n\n    if (missingColumns.length === 0 && extraColumns.length === 0) upToDate.push(model.modelName);\n    else drift.push({ table: model.modelName, missingColumns, extraColumns });\n  }\n\n  return { dialect, statements, upToDate, drift };\n}\n\n/** Column names of a table, lowercased, or undefined when it does not exist. */\nasync function describeTable(\n  executor: FarmSchemaExecutor,\n  dialect: FarmSqlDialect,\n  table: string,\n): Promise<Set<string> | undefined> {\n  if (dialect === \"sqlite\") {\n    const rows = await executor.query(`pragma table_info('${table.split(\"'\").join(\"''\")}')`);\n    if (rows.length === 0) return undefined;\n    return new Set(rows.map((row) => String(row.name).toLowerCase()));\n  }\n\n  const rows = await executor.query(\n    \"select column_name from information_schema.columns where table_name = ?\",\n    [table],\n  );\n  if (rows.length === 0) return undefined;\n  return new Set(rows.map((row) => String(row.column_name ?? row.COLUMN_NAME).toLowerCase()));\n}\n\nexport type FarmSchemaMigrateResult = {\n  applied: string[];\n  skipped: FarmSchemaDrift[];\n};\n\n/**\n * Run the plan's create statements. Drift is never applied: a plan that reports\n * differences leaves those tables untouched and says so.\n */\nexport async function applySchemaMigration(\n  plan: FarmSchemaMigratePlan,\n  executor: FarmSchemaExecutor,\n): Promise<FarmSchemaMigrateResult> {\n  const applied: string[] = [];\n  for (const statement of plan.statements) {\n    await executor.execute(statement.sql);\n    applied.push(statement.target);\n  }\n  return { applied, skipped: plan.drift };\n}\n\n/** Render a plan as a reviewable SQL file. */\nexport function formatSchemaMigration(plan: FarmSchemaMigratePlan, owner: string): string {\n  const header = [\n    `-- Generated by \\`farm ${owner} migrate\\` from the ${owner} schema.`,\n    `-- Dialect: ${plan.dialect}`,\n    \"-- Review before applying. Farm never alters existing tables.\",\n  ];\n\n  if (plan.statements.length === 0) {\n    header.push(\"--\", \"-- Nothing to create: every declared model already has a table.\");\n    return `${header.join(\"\\n\")}\\n`;\n  }\n\n  return `${header.join(\"\\n\")}\\n\\n${plan.statements.map((statement) => statement.sql).join(\"\\n\\n\")}\\n`;\n}\n\n/** Human-readable summary of tables that exist but no longer match the schema. */\nexport function describeSchemaDrift(drift: readonly FarmSchemaDrift[]): string {\n  return drift\n    .map((entry) => {\n      const lines = [`  ${entry.table}`];\n      if (entry.missingColumns.length > 0) {\n        lines.push(`    missing in the database: ${entry.missingColumns.join(\", \")}`);\n      }\n      if (entry.extraColumns.length > 0) {\n        lines.push(`    not in the schema: ${entry.extraColumns.join(\", \")}`);\n      }\n      return lines.join(\"\\n\");\n    })\n    .join(\"\\n\");\n}\n\n/**\n * Adapt a raw database client to the executor the planner needs.\n *\n * Each client reports rows differently, so the shape is detected rather than\n * configured: `pg` returns `{ rows }`, `mysql2` returns `[rows]`, and\n * `node:sqlite` exposes prepare/exec. A key-value storage mount has no tables,\n * which is reported as `null` rather than an error.\n */\nexport function createSchemaExecutor(\n  client: unknown,\n  owner: string,\n): { executor: FarmSchemaExecutor; dialect: FarmSqlDialect } | null {\n  const candidate = client as Record<string, any>;\n\n  if (\n    candidate &&\n    typeof candidate.getItem === \"function\" &&\n    typeof candidate.setItem === \"function\"\n  ) {\n    return null;\n  }\n\n  if (typeof candidate?.prepare === \"function\" && typeof candidate?.exec === \"function\") {\n    return {\n      dialect: \"sqlite\",\n      executor: {\n        async execute(sql) {\n          candidate.exec(sql);\n        },\n        async query(sql) {\n          return candidate.prepare(sql).all() as Record<string, unknown>[];\n        },\n      },\n    };\n  }\n\n  if (typeof candidate?.query === \"function\") {\n    return {\n      // Postgres and MySQL are told apart by what `query` resolves to, which is\n      // only knowable at call time, so the dialect is settled on first use.\n      dialect: \"postgres\",\n      executor: {\n        async execute(sql) {\n          await candidate.query(sql);\n        },\n        async query(sql, params) {\n          const result = await candidate.query(sql, params);\n          if (Array.isArray(result)) return (result[0] ?? []) as Record<string, unknown>[];\n          return (result?.rows ?? []) as Record<string, unknown>[];\n        },\n      },\n    };\n  }\n\n  throw new Error(\n    `${owner}: the configured client cannot run migrations. Pass a pg, mysql, or sqlite ` +\n      \"connection, or create the tables with your own migration tooling.\",\n  );\n}\n","import type { FarmSchema } from \"./schema\";\nimport {\n  applySchemaMigration,\n  createSchemaExecutor,\n  describeSchemaDrift,\n  formatSchemaMigration,\n  planSchemaMigration,\n  type FarmSchemaMigratePlan,\n} from \"./schema-migrate\";\nimport { collectSchemaModels, type CollectedSchemaModel, type FarmSqlDialect } from \"./schema-sql\";\n\n/**\n * Attached to a plugin or integration to say \"I own these tables\".\n *\n * Read by tooling so it can reach an already-resolved schema and connection\n * instead of re-reading and re-validating configuration.\n */\nexport const FARM_SCHEMA_TABLES = Symbol.for(\"farm.schema-tables\");\n\nexport interface FarmSchemaTablesDeclaration {\n  /** Command namespace: this is the `<name>` in `farm <name> migrate`. */\n  name: string;\n  /** The schema whose models this owner stores. */\n  schema: FarmSchema;\n  /**\n   * Model keys this owner actually controls. Defaults to every model in the\n   * schema; narrow it when an app shares one schema with the rest of its code.\n   */\n  models?: readonly string[];\n  /**\n   * Resolves the configured database client, or the storage mount behind it.\n   *\n   * The app's resolved config is passed because an owner may read its\n   * connection from there rather than from its own options — an integration\n   * configured through `storage.client`, for example.\n   */\n  resolveClient(config: FarmSchemaOwnerConfig): Promise<unknown>;\n  /** Set explicitly when the client's dialect cannot be detected. */\n  dialect?: FarmSqlDialect;\n}\n\n/**\n * Declare that a plugin owns tables, so `farm <name> migrate` can create them\n * and `farm generate` can include them in schema artifacts.\n *\n * ```ts\n * const plugin = definePlugin({ name: \"farm:jobs\", ... });\n *\n * return declareSchemaTables(plugin, {\n *   name: \"jobs\",\n *   schema: options.schema,\n *   models: [\"jobs\", \"jobRuns\"],\n *   resolveClient: () => resolveClient(options),\n * });\n * ```\n *\n * The declaration is non-enumerable, so it never reaches a config serializer or\n * a plugin's own option spreading.\n */\nexport function declareSchemaTables<TTarget extends object>(\n  target: TTarget,\n  declaration: FarmSchemaTablesDeclaration,\n): TTarget {\n  Object.defineProperty(target, FARM_SCHEMA_TABLES, {\n    value: declaration,\n    enumerable: false,\n    configurable: true,\n  });\n  return target;\n}\n\n/** The declaration on a plugin, when it has one. */\nexport function readSchemaTables(candidate: unknown): FarmSchemaTablesDeclaration | undefined {\n  if (!candidate || (typeof candidate !== \"object\" && typeof candidate !== \"function\")) {\n    return undefined;\n  }\n  return (candidate as Record<symbol, FarmSchemaTablesDeclaration>)[FARM_SCHEMA_TABLES];\n}\n\n/**\n * Every table owner an app has configured.\n *\n * Plugins and integrations are both searched, because either can own storage.\n */\nexport function findSchemaTableOwners(config: {\n  plugins?: readonly unknown[];\n  integrations?: Record<string, unknown> | readonly unknown[];\n}): FarmSchemaTablesDeclaration[] {\n  const integrations = config.integrations;\n  const candidates = [\n    ...(config.plugins ?? []),\n    ...(Array.isArray(integrations) ? integrations : Object.values(integrations ?? {})),\n  ];\n\n  const owners: FarmSchemaTablesDeclaration[] = [];\n  for (const candidate of candidates) {\n    const declaration = readSchemaTables(candidate);\n    // An integration may contribute plugins; its tables can be declared on\n    // either, so both are checked and duplicates collapse by name.\n    if (declaration && !owners.some((owner) => owner.name === declaration.name)) {\n      owners.push(declaration);\n    }\n  }\n  return owners;\n}\n\n/** Resolve one owner's declaration into the models tooling works with. */\nexport function collectOwnerModels(owner: FarmSchemaTablesDeclaration): CollectedSchemaModel[] {\n  return collectSchemaModels([[owner.name, owner.schema, owner.models]]);\n}\n\n/** What an owner may read when resolving its client. */\nexport type FarmSchemaOwnerConfig = {\n  storage?: unknown;\n  integrations?: Record<string, unknown> | readonly unknown[];\n  [key: string]: unknown;\n};\n\nexport interface MigrateSchemaTablesOptions {\n  /** The app's resolved config, handed to the owner's `resolveClient`. */\n  config?: FarmSchemaOwnerConfig;\n  /** Write the plan to this path instead of applying it. */\n  write?: string;\n  /** Execute the plan. */\n  apply?: boolean;\n  log?: (message: string) => void;\n}\n\nexport interface MigrateSchemaTablesResult {\n  plan: FarmSchemaMigratePlan;\n  sql: string;\n  applied: string[];\n}\n\n/**\n * Plan, and optionally apply, the tables one owner needs.\n *\n * Nothing is executed unless `apply` is set: the default is to hand back sql a\n * person can read before it touches a database.\n */\nexport async function migrateSchemaTables(\n  owner: FarmSchemaTablesDeclaration,\n  options: MigrateSchemaTablesOptions = {},\n): Promise<MigrateSchemaTablesResult> {\n  const log = options.log ?? (() => {});\n  const client = await owner.resolveClient(options.config ?? {});\n  const adapter = createSchemaExecutor(client, owner.name);\n\n  if (!adapter) {\n    log(\n      `Nothing to create: ${owner.name} stores data through a storage mount, which has no tables.`,\n    );\n    return {\n      plan: { dialect: \"sqlite\", statements: [], upToDate: [], drift: [] },\n      sql: \"\",\n      applied: [],\n    };\n  }\n\n  const { executor, dialect } = adapter;\n  const models = collectOwnerModels(owner);\n  const plan = await planSchemaMigration(models, owner.dialect ?? dialect, executor);\n  const sql = formatSchemaMigration(plan, owner.name);\n\n  if (plan.upToDate.length > 0) {\n    log(`Already up to date: ${plan.upToDate.join(\", \")}`);\n  }\n  if (plan.drift.length > 0) {\n    log(\n      `These tables exist but no longer match the schema. Farm will not change them:\\n${describeSchemaDrift(plan.drift)}`,\n    );\n  }\n  if (plan.statements.length === 0) {\n    log(\"Nothing to create.\");\n    return { plan, sql, applied: [] };\n  }\n\n  if (options.write) {\n    const { writeFile, mkdir } = await import(\"node:fs/promises\");\n    const { dirname } = await import(\"node:path\");\n    await mkdir(dirname(options.write), { recursive: true });\n    await writeFile(options.write, sql, \"utf8\");\n    log(`Wrote ${plan.statements.length} statement(s) to ${options.write}`);\n    return { plan, sql, applied: [] };\n  }\n\n  if (!options.apply) {\n    log(sql);\n    return { plan, sql, applied: [] };\n  }\n\n  const applied = await applySchemaMigration(plan, executor);\n  log(`Created: ${applied.applied.join(\", \")}`);\n  return { plan, sql, applied: applied.applied };\n}\n","import type { ViteDevServer, ModuleNode } from \"vite\";\nimport { toPosixPath } from \"./utils\";\n\nexport class HMRManager {\n  private server: ViteDevServer;\n\n  constructor(server: ViteDevServer) {\n    this.server = server;\n  }\n\n  /**\n   * Send HMR update to client\n   */\n  async send(payload: any) {\n    this.server.ws.send(payload);\n  }\n\n  /**\n   * Trigger full page reload\n   */\n  async reloadPage() {\n    this.server.ws.send({\n      type: \"full-reload\",\n      path: \"*\",\n    });\n  }\n\n  /**\n   * Handle file change and trigger HMR\n   */\n  async handleFileChange(file: string) {\n    const module = await this.server.moduleGraph.getModuleByUrl(file);\n    const normalizedFile = toPosixPath(file);\n\n    if (!module) {\n      return;\n    }\n\n    // Invalidate module\n    this.server.moduleGraph.invalidateModule(module);\n\n    // Get affected modules\n    const affectedModules = this.getAffectedModules(module);\n\n    if (affectedModules.size === 0) {\n      return;\n    }\n\n    if (\n      normalizedFile.includes(\"/app/\") &&\n      /\\/page\\.(?:tsx?|jsx?|vue|svelte)$/.test(normalizedFile)\n    ) {\n      await this.reloadPage();\n      return;\n    }\n\n    if (\n      normalizedFile.includes(\"/app/\") &&\n      /\\/layout\\.(?:tsx?|jsx?|vue|svelte)$/.test(normalizedFile)\n    ) {\n      await this.reloadPage();\n      return;\n    }\n    // Send update for other files\n    this.send({\n      type: \"update\",\n      updates: Array.from(affectedModules).map((m) => ({\n        type: m.type === \"css\" ? \"css-update\" : \"js-update\",\n        path: m.url,\n        acceptedPath: m.url,\n        timestamp: Date.now(),\n      })),\n    });\n  }\n\n  /**\n   * Get all affected modules in the dependency graph\n   */\n  private getAffectedModules(module: ModuleNode): Set<ModuleNode> {\n    const affected = new Set<ModuleNode>();\n    const seen = new Set<ModuleNode>();\n\n    const traverse = (mod: ModuleNode) => {\n      if (seen.has(mod)) return;\n      seen.add(mod);\n      affected.add(mod);\n\n      // A self-accepting module is the HMR boundary: it re-runs with the\n      // update, so nothing above it is affected.\n      if (mod.isSelfAccepting) return;\n\n      for (const importer of mod.importers) {\n        // An importer that accepts this dependency is likewise a boundary:\n        // it receives the update, but its own importers do not. Accepting is\n        // per-edge, so the importer stays traversable via other dependencies.\n        if (importer.acceptedHmrDeps?.has(mod)) {\n          affected.add(importer);\n          continue;\n        }\n        traverse(importer);\n      }\n    };\n\n    traverse(module);\n    return affected;\n  }\n\n  /**\n   * Handle custom HMR events from client\n   */\n  onClientMessage(event: string, callback: (data: any) => void) {\n    // Vite handles this via ws.on\n  }\n}\n\n/**\n * Create HMR client code for injection\n */\nexport function createHMRClientCode(): string {\n  return `\n// Farm.js HMR Client\nif (import.meta.hot) {\n  // Accept HMR updates for this module\n  import.meta.hot.accept((newModule) => {\n    if (newModule) {\n      // Module updated, trigger re-render\n      window.location.reload();\n    }\n  });\n\n  // Listen for custom Farm.js events\n  import.meta.hot.on('farm:route-update', (data) => {\n    console.log('Route updated:', data.path);\n    window.location.reload();\n  });\n\n  // Handle CSS updates\n  import.meta.hot.on('vite:beforeUpdate', () => {\n    console.log('[Farm.js] HMR update incoming...');\n  });\n\n  import.meta.hot.on('vite:afterUpdate', () => {\n    console.log('[Farm.js] HMR update applied ✓');\n  });\n\n  // Handle errors\n  import.meta.hot.on('vite:error', (err) => {\n    console.error('[Farm.js] HMR error:', err);\n  });\n}\n`;\n}\n","import React from \"react\";\n\ninterface ScalarAPIDocumentationProps {\n  spec: any;\n  config?: {\n    theme?: \"default\" | \"purple\" | \"blue\" | \"green\" | \"red\" | \"yellow\";\n    layout?: \"modern\" | \"classic\";\n    showSidebar?: boolean;\n    hideDownloadButton?: boolean;\n    hideTryItPanel?: boolean;\n  };\n}\n\nexport function ScalarAPIDocumentation({ spec, config = {} }: ScalarAPIDocumentationProps) {\n  const [isLoaded, setIsLoaded] = React.useState(false);\n\n  React.useEffect(() => {\n    // Dynamically import Scalar components\n    const loadScalar = async () => {\n      try {\n        // Load Scalar CSS\n        const cssLink = document.createElement(\"link\");\n        cssLink.rel = \"stylesheet\";\n        cssLink.href = \"https://cdn.jsdelivr.net/npm/@scalar/api-reference@latest/dist/style.css\";\n        document.head.appendChild(cssLink);\n\n        // Load Scalar JS\n        const script = document.createElement(\"script\");\n        script.src =\n          \"https://cdn.jsdelivr.net/npm/@scalar/api-reference@latest/dist/browser/standalone.js\";\n        script.onload = () => setIsLoaded(true);\n        document.head.appendChild(script);\n      } catch (error) {\n        console.error(\"Failed to load Scalar:\", error);\n      }\n    };\n\n    loadScalar();\n  }, []);\n\n  React.useEffect(() => {\n    if (isLoaded && window.ScalarApiReference) {\n      // Initialize Scalar\n      const container = document.getElementById(\"scalar-api-reference\");\n      if (container) {\n        window.ScalarApiReference({\n          spec,\n          theme: config.theme || \"default\",\n          layout: config.layout || \"modern\",\n          showSidebar: config.showSidebar !== false,\n          hideDownloadButton: config.hideDownloadButton || false,\n          hideTryItPanel: config.hideTryItPanel || false,\n        });\n      }\n    }\n  }, [isLoaded, spec, config]);\n\n  return (\n    <div className=\"scalar-container\">\n      <div id=\"scalar-api-reference\" style={{ height: \"100vh\", width: \"100%\" }} />\n    </div>\n  );\n}\n\n// Extend window type for Scalar\ndeclare global {\n  interface Window {\n    ScalarApiReference: (config: any) => void;\n  }\n}\n","import React from \"react\";\nimport { ScalarAPIDocumentation } from \"./scalar-component\";\n\ninterface DocsRouteProps {\n  spec: any;\n  config?: any;\n}\n\nexport function DocsRoute({ spec, config }: DocsRouteProps) {\n  return (\n    <html lang=\"en\">\n      <head>\n        <meta charSet=\"utf-8\" />\n        <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\" />\n        <link rel=\"icon\" href=\"data:,\" />\n        <title>{config?.title || \"API Documentation\"}</title>\n        <style>{`\n          body {\n            margin: 0;\n            padding: 0;\n            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', sans-serif;\n          }\n          .scalar-container {\n            height: 100vh;\n            width: 100%;\n          }\n        `}</style>\n      </head>\n      <body>\n        <ScalarAPIDocumentation spec={spec} config={config} />\n      </body>\n    </html>\n  );\n}\n"],"mappings":"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","names":["rows","jsx"]}