Add inline sqlfu support for Durable Objects

[mmkal]

Summary

This PR adds inline sqlfu modules for self-contained Durable Objects. A Durable Object can keep its schema, migrations, and queries in one Worker TypeScript module as a static defineConfig(...) class property, then point the CLI at that module:

npx sqlfu --config src/durable-objects/posts.ts draft
npx sqlfu --config src/durable-objects/posts.ts generate
npx sqlfu --config src/durable-objects/posts.ts generate --watch

The inline path is source-backed, not config-import-backed: the CLI scans TypeScript source for inline defineConfig({...}) object literals on top-level consts or static properties of top-level named classes. Inline handling is enabled for draft and generate; other commands continue to require a file-backed sqlfu config.

The generated inline query shape is now compact. Users can start with plain direct sql query values, and generate rewrites them into sql.many<{...}>, sql.one<{...}>, sql.nullableOne<{...}>, or sql.run<{...}> tags. The mode tags are also available on the main sql export generally; sql.run is the preferred alias for the metadata/run-result mode, with sql.metadata still available.

Example

import {DurableObject} from 'cloudflare:workers';
import {createDurableObjectClient, defineConfig, sql} from 'sqlfu';

export class PostsObject extends DurableObject {
  static db = defineConfig({
    definitions: sql`
      create table posts (
        slug text primary key not null,
        published_at text,
        body text
      );
    `,
    migrations: [],
    queries: {
      listPosts: sql`
        select slug, published_at, body
        from posts
        order by slug
        limit :limit
      `,
      createPost: sql`
        insert into posts(slug, body)
        values (:slug, :body)
      `,
    },
  });

  db: ReturnType<typeof PostsObject.db<ReturnType<typeof createDurableObjectClient>>>;

  constructor(ctx: DurableObjectState, env: {}) {
    super(ctx, env);
    this.db = PostsObject.db(createDurableObjectClient(ctx.storage));
    this.db.migrate();
  }

  posts() {
    return this.db.listPosts({limit: 10});
  }
}

After draft and generate, sqlfu writes the migration entries and generated query metadata back into the same source module:

import {DurableObject} from 'cloudflare:workers';
import {createDurableObjectClient, defineConfig, sql} from 'sqlfu';

export class PostsObject extends DurableObject {
  static db = defineConfig({
    definitions: sql`
      create table posts (
        slug text primary key not null,
        published_at text,
        body text
      );
    `,
    migrations: [
      {
        name: '2026-05-28T00.00.00.000Z_create_posts',
        content: sql`
          create table posts (
            slug text primary key not null,
            published_at text,
            body text
          );
        `,
      },
    ],
    queries: {
      listPosts: sql.many<{ parameters: { limit: number }; result: { slug: string; published_at: string | null; body: string | null } }>`
        select slug, published_at, body
        from posts
        order by slug
        limit :limit
      `,
      createPost: sql.run<{ parameters: { slug: string; body: string | null } }>`
        insert into posts(slug, body)
        values (:slug, :body)
      `,
    },
  });

  db: ReturnType<typeof PostsObject.db<ReturnType<typeof createDurableObjectClient>>>;

  constructor(ctx: DurableObjectState, env: {}) {
    super(ctx, env);
    this.db = PostsObject.db(createDurableObjectClient(ctx.storage));
    this.db.migrate();
  }

  posts() {
    return this.db.listPosts({limit: 10});
  }
}

Before / After

Before this PR, Durable Objects had to use the normal file-backed shape: a separate sqlfu.config.ts, definitions.sql, migrations/, and sql/ directory per object. Inline modules were not supported, and generate --watch rejected inline defineConfig(...) modules.

Notes for Reviewers

• Static class properties are the recommended Durable Object shape because the config stays attached to the object that owns the storage. Module-level const configs remain supported, including multiple configs in one module.
• The public inline API is the root defineConfig(...) overload plus sql from sqlfu; there is no separate inlineSqlfu helper.
• Inline source edits infer indentation, quote style, and trailing-comma preference to avoid formatter churn when writing migrations and generated query tags.
• The source reader does not import the configured module, so Worker globals and user module side effects do not run in the Node CLI.
• Inline query result types intentionally match raw Durable Object SQLite rows: column names stay as returned by SQLite, and nullable result columns are typed as T | null.
• Inline generation rejects query shapes that need generated-wrapper runtime expansion, such as in (:ids) and object-field parameters, because the inline runtime binds the SQL template directly today.
• Inline definitions, migrations, and config queries must have no template interpolations. The public sql.many / sql.one / sql.run tags still allow interpolations in non-inline contexts.
• The source writer still handles the object-form inline query shape so existing branch output can be regenerated safely, but the docs and primary fixtures now prefer compact direct query tags.

Verification

pnpm lint --fix
pnpm --filter sqlfu typecheck
pnpm build
pnpm sync:root-readme:check
pnpm --filter sqlfu exec vitest run test/pkg.test.ts
pnpm --filter sqlfu exec vitest run test/generate-watch.test.ts
pnpm --filter sqlfu exec vitest run test/inline-source.test.ts test/config-inline.test.ts test/generate-watch.test.ts test/pkg.test.ts test/import-surface.test.ts test/adapters/durable-object.test.ts

Self-review hardening (2026-06-11)

A red/green verification pass over the whole branch (failing tests pushed first in 02a3b40, fixes after):

• Scanner robustness: the inline source scanner ran on every config load and threw on valid TypeScript — regex literals (name.replace(/['"]/g, '_') anywhere in the file broke every CLI command), spread properties, and arrow function types inside sql.many<...> type args. It now lexes regexes, skips object elements it can't model while probing, and treats => as an arrow.
• SQL comments: the runtime sql tag collapses whitespace, so a -- comment used to swallow the rest of the statement — an inline migration could be recorded as applied while its DDL never ran. Comments are now stripped (string-aware) before collapse.
• Hoisted definitions: definitions: someHoistedTag silently classified the module as file-backed, making the CLI dynamic-import the Durable Object module and crash on cloudflare:workers. It now fails with an error naming the fix.
• Drafting: appendInlineMigration no longer writes the separating comma inside a trailing // comment; static SQL is template-escape-decoded so it matches what the runtime executes.
• Generate: one failing query no longer stales every other query's types — valid types are written, then a summary error names the broken queries.
• sqlfu/api: dynamic imports are literal again (bundling sqlfu/api with esbuild now works — there's a packed-package test for it), Confirm is re-exported from core, and config()/serve()/kill() regained precise return types.
• Dead code: the {query, $type, mode} object query form (unused since compact tags) is deleted along with ~130 lines of writer machinery; inline query binding validates once at bind time and the DO adapter caches the named→positional SQL rewrite per query.
• Watch: file-backed and inline watch share one loop, and the inline watcher skips its own type-annotation writes (previously every save cost a redundant second typegen cycle).
• Published package types: a publish-shaped build used to ship .d.ts files referencing deleted vendor modules, so consumers with skipLibCheck: false couldn't compile against the package. bundle-vendor now keeps the declaration graph coherent.
• CI: the sqlfu job only ran test/migrations + test/schemadiff, which is how stale fixtures and the issues above shipped silently. It now builds (publish-shaped), typechecks, and runs the full suite.

Package size — packed 280.3 kB (+24.4 kB, +9.5%)

Package size

	main	this PR	Δ
packed	255.9 kB	280.3 kB	+9.5%
unpacked	1.03 MB	1.12 MB	+8.8%
files	190	226	+36

dist/vendor/*.js bundles

	main	this PR	Δ
vendor/sha256.js	4.3 kB	4.3 kB	0
vendor/sql-formatter/*.js	94.5 kB	94.5 kB	0
vendor/sqlfu-sqlite-parser/*.js	17.2 kB	17.2 kB	0
vendor/standard-schema/*.js	2.8 kB	2.8 kB	0
vendor/typesql/*.js	133.6 kB	134.8 kB	+0.9%

Measured with npm pack --dry-run --json on sqlfu (0.0.3-7 on main vs 0.0.3-7 on this PR).

---

Note

Medium Risk
Large surface area (source parser, CLI routing, runtime binding, vendored bundles) with extensive tests; inline configs are intentionally limited to generate/draft, reducing blast radius for migrate/serve paths.

Overview
Adds inline defineConfig for self-contained Durable Object modules: schema, migrations, and queries live in a Worker .ts file (e.g. static db = defineConfig({...})), and --config can point at that module instead of sqlfu.config.ts.

CLI & API: draft, generate, and generate --watch detect inline configs via static source parsing (no dynamic import of the Worker module). They append migration entries and rewrite queries to compact tags (sql.one<{...}>, sql.many<{...}>, sql.run<{...}>). Migrate, serve, UI, and most other commands reject inline projects with a clear error. sqlfu/api lazy-loads Node code; format is async.

Runtime: Overloaded root defineConfig returns an inline factory with migrate() and typed query methods. The sql tag gains mode helpers and strips SQL comments before whitespace collapse. Durable Object prepare() caches named-parameter rewriting.

Tooling: Shared watchAndRegenerate; vendor TypeSQL split for browser-safe analysis; bundle-vendor fixes published .d.ts; CI runs full sqlfu build, typecheck, and vitest (plus Bun for adapter tests).

^{Reviewed by Cursor Bugbot for commit 2da59d5. Bugbot is set up for automated code reviews on this repo. Configure here.}

[pkg-pr-new]

Open in StackBlitz

npm i https://pkg.pr.new/sqlfu@139

commit: 2da59d5

[cursor]

Cursor Bugbot has reviewed your changes and found 1 potential issue.

^{❌ Bugbot Autofix is OFF. To automatically fix reported issues with cloud agents, enable autofix in the Cursor dashboard.}

^{Reviewed by Cursor Bugbot for commit 48cd01f. Configure here.}