frappebun 0.0.0

package/src/database/schema.ts

@@ -0,0 +1,188 @@
+/**
+ * Schema management — create and alter tables from DocType definitions.
+ */
+
+import type { Database as BunSQLite } from "bun:sqlite"
+
+import { toTableName, getAllDocTypes, getDocTypeMeta } from "../doctype/registry"
+import type { DocTypeDefinition, FieldType } from "../doctype/types"
+
+interface PragmaTableInfoRow {
+  cid: number
+  name: string
+  type: string
+  notnull: number
+  dflt_value: string | null
+  pk: number
+}
+
+interface SqliteMasterRow {
+  name: string
+}
+
+/**
+ * Map field type to SQLite column type.
+ */
+function sqliteColumnType(fieldType: FieldType): string {
+  switch (fieldType) {
+    case "Int":
+    case "Check":
+    case "Rating":
+      return "INTEGER"
+    case "Float":
+    case "Currency":
+    case "Percent":
+      return "REAL"
+    case "Table":
+      return "" // no column — child tables are separate
+    default:
+      return "TEXT"
+  }
+}
+
+/**
+ * Build CREATE TABLE SQL for a DocType.
+ */
+export function buildCreateTableSQL(def: DocTypeDefinition): string[] {
+  const tableName = toTableName(def.name)
+  const statements: string[] = []
+
+  const columns: string[] = [
+    `"name" VARCHAR(140) PRIMARY KEY`,
+    `"creation" TEXT`,
+    `"modified" TEXT`,
+    `"modifiedBy" VARCHAR(140)`,
+    `"owner" VARCHAR(140)`,
+    `"docstatus" INTEGER DEFAULT 0`,
+    `"idx" INTEGER DEFAULT 0`,
+  ]
+
+  if (def.schema.isChild) {
+    columns.push(`"parent" VARCHAR(140)`, `"parentType" VARCHAR(140)`, `"parentField" VARCHAR(140)`)
+  }
+
+  for (const [fieldName, fieldDef] of Object.entries(def.schema.fields)) {
+    if (fieldDef.type === "Table") continue
+
+    const colType = sqliteColumnType(fieldDef.type)
+    let colDef = `"${fieldName}" ${colType}`
+
+    if (fieldDef.default !== undefined) {
+      if (typeof fieldDef.default === "string") {
+        colDef += ` DEFAULT '${fieldDef.default}'`
+      } else if (typeof fieldDef.default === "number") {
+        colDef += ` DEFAULT ${fieldDef.default}`
+      }
+    }
+
+    columns.push(colDef)
+  }
+
+  statements.push(`CREATE TABLE IF NOT EXISTS "${tableName}" (\n  ${columns.join(",\n  ")}\n)`)
+
+  // Indexes
+  for (const [fieldName, fieldDef] of Object.entries(def.schema.fields)) {
+    if (fieldDef.unique) {
+      statements.push(
+        `CREATE UNIQUE INDEX IF NOT EXISTS "idx_${tableName}_${fieldName}" ON "${tableName}" ("${fieldName}")`,
+      )
+    } else if (fieldDef.type === "Link" || fieldDef.inStandardFilter) {
+      statements.push(
+        `CREATE INDEX IF NOT EXISTS "idx_${tableName}_${fieldName}" ON "${tableName}" ("${fieldName}")`,
+      )
+    }
+  }
+
+  if (def.schema.isChild) {
+    statements.push(
+      `CREATE INDEX IF NOT EXISTS "idx_${tableName}_parent" ON "${tableName}" ("parent")`,
+    )
+  }
+
+  statements.push(
+    `CREATE INDEX IF NOT EXISTS "idx_${tableName}_modified" ON "${tableName}" ("modified")`,
+  )
+
+  return statements
+}
+
+/**
+ * Build ALTER TABLE statements to add missing columns.
+ */
+export function buildAlterTableSQL(def: DocTypeDefinition, existingColumns: Set<string>): string[] {
+  const tableName = toTableName(def.name)
+  const statements: string[] = []
+
+  for (const [fieldName, fieldDef] of Object.entries(def.schema.fields)) {
+    if (fieldDef.type === "Table") continue
+    if (existingColumns.has(fieldName)) continue
+
+    const colType = sqliteColumnType(fieldDef.type)
+    let defaultClause = ""
+    if (fieldDef.default !== undefined) {
+      if (typeof fieldDef.default === "string") {
+        defaultClause = ` DEFAULT '${fieldDef.default}'`
+      } else if (typeof fieldDef.default === "number") {
+        defaultClause = ` DEFAULT ${fieldDef.default}`
+      }
+    }
+
+    statements.push(
+      `ALTER TABLE "${tableName}" ADD COLUMN "${fieldName}" ${colType}${defaultClause}`,
+    )
+  }
+
+  return statements
+}
+
+/**
+ * Get existing column names for a table.
+ */
+export function getExistingColumns(db: BunSQLite, tableName: string): Set<string> {
+  const columns = new Set<string>()
+  try {
+    const rows = db.query<PragmaTableInfoRow, []>(`PRAGMA table_info("${tableName}")`).all()
+    for (const row of rows) {
+      columns.add(row.name)
+    }
+  } catch {
+    // Table doesn't exist
+  }
+  return columns
+}
+
+/**
+ * Check if a table exists.
+ */
+export function tableExists(db: BunSQLite, tableName: string): boolean {
+  const result = db
+    .query<SqliteMasterRow, [string]>(
+      `SELECT name FROM sqlite_master WHERE type='table' AND name=?`,
+    )
+    .get(tableName)
+  return result != null
+}
+
+/**
+ * Sync all registered DocTypes to the database.
+ * Creates tables that don't exist, adds columns that are missing.
+ */
+export function syncSchema(db: BunSQLite): void {
+  for (const dtName of getAllDocTypes()) {
+    const def = getDocTypeMeta(dtName)
+    if (!def || def.schema.isVirtual) continue
+
+    const tableName = toTableName(def.name)
+
+    if (!tableExists(db, tableName)) {
+      for (const stmt of buildCreateTableSQL(def)) {
+        db.run(stmt)
+      }
+    } else {
+      const existingCols = getExistingColumns(db, tableName)
+      for (const stmt of buildAlterTableSQL(def, existingCols)) {
+        db.run(stmt)
+      }
+    }
+  }
+}

package/src/doctype/define.ts

@@ -0,0 +1,45 @@
+/**
+ * doctype() and controller() — the two ambient globals that define a DocType.
+ */
+
+import { registerDocType, registerController } from "./registry"
+import type {
+  DocTypeSchema,
+  DocTypeDefinition,
+  ControllerHooks,
+  ControllerDefinition,
+} from "./types"
+
+// ─── doctype() ────────────────────────────────────────────
+
+/**
+ * Define a DocType schema. Registers it in the global registry and returns
+ * the definition. Available as an ambient global — no import needed.
+ *
+ *   export default doctype("ToDo", {
+ *     fields: { ... },
+ *     permissions: [...],
+ *   })
+ */
+export function doctype(name: string, schema: DocTypeSchema): DocTypeDefinition {
+  const def: DocTypeDefinition = { name, schema }
+  if (!schema.naming) def.schema.naming = "autoincrement"
+  registerDocType(def)
+  return def
+}
+
+// ─── controller() ─────────────────────────────────────────
+
+/**
+ * Define a controller for a DocType. Registers it immediately and returns
+ * the definition. Available as an ambient global — no import needed.
+ *
+ *   export default controller("ToDo", {
+ *     async validate(doc) { ... },
+ *     permissions: { scope(user) { ... } },
+ *   })
+ */
+export function controller(name: string, hooks: ControllerHooks): ControllerDefinition {
+  registerController(name, hooks)
+  return { name, hooks }
+}

package/src/doctype/discovery.ts

@@ -0,0 +1,57 @@
+/**
+ * Scan filesystem for DocType definitions and controllers.
+ */
+
+import { existsSync, readdirSync, statSync } from "node:fs"
+import { join } from "node:path"
+
+import { registerDocType } from "./registry"
+import type { DocTypeDefinition } from "./types"
+
+/**
+ * Discover and load all DocTypes from a doctype/ directory.
+ * Each subdirectory containing a .ts file (not .controller.ts, not .spec.ts) is a DocType.
+ *
+ * Schema files must `export default defineDocType(...)`.
+ * Controller files must `export default controller(...)`.
+ */
+export async function discoverDocTypes(doctypeDir: string): Promise<void> {
+  if (!existsSync(doctypeDir)) return
+
+  const entries = readdirSync(doctypeDir)
+
+  for (const entry of entries) {
+    const entryPath = join(doctypeDir, entry)
+    if (!statSync(entryPath).isDirectory()) continue
+
+    // Look for schema file: {name}.ts (not .controller.ts, not .spec.ts)
+    const files = readdirSync(entryPath)
+    const schemaFile = files.find(
+      (f) =>
+        f.endsWith(".ts") &&
+        !f.endsWith(".controller.ts") &&
+        !f.endsWith(".spec.ts") &&
+        !f.endsWith(".d.ts"),
+    )
+
+    if (!schemaFile) continue
+
+    // Import schema — the default export is the DocTypeDefinition
+    const schemaPath = join(entryPath, schemaFile)
+    const mod = await import(schemaPath)
+    const def: DocTypeDefinition | undefined = mod.default
+
+    // If the module was previously imported and the DocType is already registered
+    // (via the defineDocType side-effect), the def is what was returned.
+    // If the registry was cleared, we need to re-register from the returned def.
+    if (def?.name && def?.schema) {
+      registerDocType(def)
+    }
+
+    // Controller files self-register when imported (controller() registers as a side effect)
+    const controllerFile = files.find((f) => f.endsWith(".controller.ts"))
+    if (controllerFile) {
+      await import(join(entryPath, controllerFile))
+    }
+  }
+}

package/src/doctype/field.ts

@@ -0,0 +1,160 @@
+/**
+ * The `field` factory — creates FieldDefinition objects for use in defineDocType().
+ * All methods return pure data, no side effects.
+ */
+
+import type { FieldDefinition, FieldOptions } from "./types"
+
+function makeField(type: FieldDefinition["type"], opts?: FieldOptions): FieldDefinition {
+  const def: FieldDefinition = { type }
+  if (opts) {
+    Object.assign(def, opts)
+  }
+  return def
+}
+
+export const field = {
+  // ─── Data Fields ──────────────────────────────────────────
+  data(opts?: FieldOptions): FieldDefinition {
+    return makeField("Data", opts)
+  },
+
+  int(opts?: FieldOptions): FieldDefinition {
+    return makeField("Int", opts)
+  },
+
+  float(opts?: FieldOptions): FieldDefinition {
+    return makeField("Float", opts)
+  },
+
+  currency(opts?: FieldOptions): FieldDefinition {
+    return makeField("Currency", opts)
+  },
+
+  percent(opts?: FieldOptions): FieldDefinition {
+    return makeField("Percent", opts)
+  },
+
+  check(opts?: FieldOptions): FieldDefinition {
+    return makeField("Check", opts)
+  },
+
+  rating(opts?: FieldOptions): FieldDefinition {
+    return makeField("Rating", opts)
+  },
+
+  // ─── Text Fields ─────────────────────────────────────────
+  text(opts?: FieldOptions): FieldDefinition {
+    return makeField("Text", opts)
+  },
+
+  smallText(opts?: FieldOptions): FieldDefinition {
+    return makeField("SmallText", opts)
+  },
+
+  longText(opts?: FieldOptions): FieldDefinition {
+    return makeField("LongText", opts)
+  },
+
+  textEditor(opts?: FieldOptions): FieldDefinition {
+    return makeField("TextEditor", opts)
+  },
+
+  markdownEditor(opts?: FieldOptions): FieldDefinition {
+    return makeField("MarkdownEditor", opts)
+  },
+
+  code(opts?: FieldOptions): FieldDefinition {
+    return makeField("Code", opts)
+  },
+
+  htmlEditor(opts?: FieldOptions): FieldDefinition {
+    return makeField("HtmlEditor", opts)
+  },
+
+  json(opts?: FieldOptions): FieldDefinition {
+    return makeField("JSON", opts)
+  },
+
+  // ─── Date/Time Fields ────────────────────────────────────
+  date(opts?: FieldOptions): FieldDefinition {
+    return makeField("Date", opts)
+  },
+
+  datetime(opts?: FieldOptions): FieldDefinition {
+    return makeField("Datetime", opts)
+  },
+
+  time(opts?: FieldOptions): FieldDefinition {
+    return makeField("Time", opts)
+  },
+
+  duration(opts?: FieldOptions): FieldDefinition {
+    return makeField("Duration", opts)
+  },
+
+  // ─── Selection Fields ────────────────────────────────────
+  select(options: string[], opts?: FieldOptions): FieldDefinition {
+    return { ...makeField("Select", opts), selectOptions: options }
+  },
+
+  link(doctype: string, opts?: FieldOptions): FieldDefinition {
+    return { ...makeField("Link", opts), doctype }
+  },
+
+  dynamicLink(linkField: string, opts?: FieldOptions): FieldDefinition {
+    return { ...makeField("DynamicLink", opts), linkField }
+  },
+
+  tableMultiSelect(doctype: string, opts?: FieldOptions): FieldDefinition {
+    return { ...makeField("TableMultiSelect", opts), doctype }
+  },
+
+  // ─── Table Fields ────────────────────────────────────────
+  table(
+    doctypeOrFields: string | Record<string, FieldDefinition>,
+    opts?: FieldOptions,
+  ): FieldDefinition {
+    if (typeof doctypeOrFields === "string") {
+      return { ...makeField("Table", opts), childDocType: doctypeOrFields }
+    }
+    return { ...makeField("Table", opts), childFields: doctypeOrFields }
+  },
+
+  // ─── Special Fields ──────────────────────────────────────
+  attach(opts?: FieldOptions): FieldDefinition {
+    return makeField("Attach", opts)
+  },
+
+  attachImage(opts?: FieldOptions): FieldDefinition {
+    return makeField("AttachImage", opts)
+  },
+
+  image(opts?: FieldOptions): FieldDefinition {
+    return makeField("Image", opts)
+  },
+
+  color(opts?: FieldOptions): FieldDefinition {
+    return makeField("Color", opts)
+  },
+
+  signature(opts?: FieldOptions): FieldDefinition {
+    return makeField("Signature", opts)
+  },
+
+  geolocation(opts?: FieldOptions): FieldDefinition {
+    return makeField("Geolocation", opts)
+  },
+
+  password(opts?: FieldOptions): FieldDefinition {
+    return makeField("Password", opts)
+  },
+
+  readOnly(opts?: FieldOptions): FieldDefinition {
+    return makeField("ReadOnly", opts)
+  },
+
+  htmlField(opts?: FieldOptions): FieldDefinition {
+    return makeField("HtmlField", opts)
+  },
+}

package/src/doctype/index.ts

@@ -0,0 +1,20 @@
+/**
+ * DocType module — re-exports everything.
+ */
+
+export * from "./types"
+export { field } from "./field"
+export { section, column, tab } from "./layout"
+export { doctype, controller } from "./define"
+export {
+  registerDocType,
+  registerController,
+  getDocTypeMeta,
+  getController,
+  getAllDocTypes,
+  hasDocType,
+  clearRegistry,
+  getDocTypeFields,
+  toTableName,
+} from "./registry"
+export { discoverDocTypes } from "./discovery"

package/src/doctype/layout.ts

@@ -0,0 +1,62 @@
+/**
+ * Layout helpers: section(), column(), tab()
+ */
+
+import type { LayoutSection, LayoutColumn, LayoutTab } from "./types"
+
+export function column(fields: string[]): LayoutColumn {
+  return { _type: "column", fields }
+}
+
+export function section(...args: any[]): LayoutSection {
+  // Overloads:
+  // section(fields: string[])
+  // section(title: string, fields: string[])
+  // section(columns: LayoutColumn[])
+  // section(title: string, columns: LayoutColumn[])
+  // section(title: string, opts: object, content: any[])
+
+  if (args.length === 1) {
+    const [arg] = args
+    if (Array.isArray(arg) && arg.length > 0 && typeof arg[0] === "string") {
+      return { _type: "section", fields: arg }
+    }
+    if (Array.isArray(arg) && arg.length > 0 && arg[0]?._type === "column") {
+      return { _type: "section", columns: arg }
+    }
+    return { _type: "section", fields: arg ?? [] }
+  }
+
+  if (args.length === 2) {
+    const [first, second] = args
+    if (typeof first === "string" && Array.isArray(second)) {
+      if (second.length > 0 && second[0]?._type === "column") {
+        return { _type: "section", title: first, columns: second }
+      }
+      return { _type: "section", title: first, fields: second }
+    }
+  }
+
+  if (args.length === 3) {
+    const [title, opts, content] = args
+    if (typeof title === "string" && typeof opts === "object" && !Array.isArray(opts)) {
+      const result: LayoutSection = {
+        _type: "section",
+        title,
+        ...opts,
+      }
+      if (Array.isArray(content) && content.length > 0 && content[0]?._type === "column") {
+        result.columns = content
+      } else {
+        result.fields = content
+      }
+      return result
+    }
+  }
+
+  return { _type: "section", fields: [] }
+}
+
+export function tab(label: string, sections: LayoutSection[]): LayoutTab {
+  return { _type: "tab", label, sections }
+}

package/src/doctype/query-builder-stub.ts

@@ -0,0 +1,16 @@
+/**
+ * Minimal interface stub for QueryBuilder — avoids circular imports
+ * between doctype/types.ts and database/query-builder.ts.
+ */
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export interface QueryBuilderLike {
+  where(...args: unknown[]): QueryBuilderLike
+  select(...args: unknown[]): QueryBuilderLike
+  limit(n: number): QueryBuilderLike
+  offset(n: number): QueryBuilderLike
+  orderBy(...args: unknown[]): QueryBuilderLike
+  all<T = Record<string, unknown>>(): Promise<T[]>
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  [key: string]: any
+}

package/src/doctype/registry.ts

@@ -0,0 +1,106 @@
+/**
+ * DocType registry — stores all registered DocType definitions in memory.
+ */
+
+import type { DocTypeDefinition, ControllerHooks, FieldDefinition } from "./types"
+import { RESERVED_FIELD_NAMES as RESERVED } from "./types"
+
+/** Global DocType registry — maps DocType name → definition */
+const registry = new Map<string, DocTypeDefinition>()
+
+/** Controller registry — maps DocType name → controller hooks */
+const controllers = new Map<string, ControllerHooks>()
+
+/**
+ * Convert a DocType name to its table name.
+ * "Sales Invoice" → "SalesInvoice"
+ * "ToDo" → "ToDo"
+ */
+export function toTableName(doctypeName: string): string {
+  return doctypeName.replace(/\s+/g, "")
+}
+
+/**
+ * Register a DocType definition.
+ */
+export function registerDocType(def: DocTypeDefinition): void {
+  // Validate reserved field names
+  for (const fieldName of Object.keys(def.schema.fields)) {
+    if (RESERVED.has(fieldName)) {
+      throw new Error(
+        `DocType "${def.name}": field name "${fieldName}" is reserved. ` +
+          `Reserved names: ${[...RESERVED].join(", ")}`,
+      )
+    }
+  }
+
+  // Register inline child tables (only if not already processed)
+  for (const [fieldName, fieldDef] of Object.entries(def.schema.fields)) {
+    if (fieldDef.type === "Table" && fieldDef.childFields && !fieldDef.childDocType) {
+      const childName = `${def.name} ${fieldName.charAt(0).toUpperCase() + fieldName.slice(1)}`
+      const childDef: DocTypeDefinition = {
+        name: childName,
+        schema: {
+          isChild: true,
+          naming: "autoincrement",
+          fields: fieldDef.childFields,
+        },
+      }
+      registry.set(childName, childDef)
+      // Update field to reference the generated child DocType
+      fieldDef.childDocType = childName
+    }
+  }
+
+  registry.set(def.name, def)
+}
+
+/**
+ * Register a controller for a DocType.
+ */
+export function registerController(doctype: string, hooks: ControllerHooks): void {
+  controllers.set(doctype, hooks)
+}
+
+/**
+ * Get a DocType definition by name.
+ */
+export function getDocTypeMeta(name: string): DocTypeDefinition | undefined {
+  return registry.get(name)
+}
+
+/**
+ * Get controller hooks for a DocType.
+ */
+export function getController(name: string): ControllerHooks | undefined {
+  return controllers.get(name)
+}
+
+/**
+ * Get all registered DocType names.
+ */
+export function getAllDocTypes(): string[] {
+  return [...registry.keys()]
+}
+
+/**
+ * Check if a DocType is registered.
+ */
+export function hasDocType(name: string): boolean {
+  return registry.has(name)
+}
+
+/**
+ * Clear the registry (for testing).
+ */
+export function clearRegistry(): void {
+  registry.clear()
+  controllers.clear()
+}
+
+/**
+ * Get all fields for a DocType including standard fields metadata.
+ */
+export function getDocTypeFields(name: string): Record<string, FieldDefinition> | undefined {
+  return registry.get(name)?.schema.fields
+}