Getting Started

SQLQueryHelperjs has two main usage modes:

• define schema in code and evolve it at runtime
• inspect an existing database and generate classes from it

Core Mental Model

The library is organized around four layers:

1. Schema helpers such as column, entity, primaryKey, foreignKey, and index.
2. Runtime engines such as SqliteReflector, PostgresReflector, and MySqlReflector.
3. Fluent query builders for select, insert, update, and delete flows.
4. Inspector functions that reverse-engineer an existing database into code or structured metadata.

Engine Status

Current runtime engines:

• SQLite
• PostgreSQL
• MySQL

Planned documentation tracks:

• SQL Server

SQLite Quick Start

import { SqliteReflector, column, entity, primaryKey } from "sqlqueryhelperjs";

class User {
  static entity = entity({
    table: "users",
    columns: {
      id: column.integer(),
      email: column.text({ nullable: false }),
    },
    primaryKey: primaryKey("id", { autoIncrement: true }),
  });
}

const db = new SqliteReflector({ filename: "app.db" });

db.reflect(User);

const rows = db.select(["id", "email"]).from("users").all();
Copy

PostgreSQL Quick Start

import { PostgresReflector, column, entity, primaryKey } from "sqlqueryhelperjs";

class User {
  static entity = entity({
    table: "public.users",
    columns: {
      id: column.integer(),
      email: column.text({ nullable: false }),
    },
    primaryKey: primaryKey("id"),
  });
}

const db = new PostgresReflector({
  connectionString: "postgres://user:pass@localhost:5432/app",
});

await db.reflect(User);

const rows = await db
  .select(["id", "email"])
  .from("public.users")
  .all();
Copy

MySQL And SQL Server

The documentation now separates MySQL and SQL Server into their own guides so each engine can grow independently.

MySQL is already part of the exported runtime surface and documents the implemented reflector, inspector, query builder, and advanced runtime features.

SQL Server remains a documentation boundary for planned support and is not exported yet.

Existing Database First

If the database already exists, start with the inspectors:

• inspectSqliteSchema
• generateSqliteSchemaOutput
• inspectPostgresSchema
• generatePostgresSchemaOutput
• inspectMySqlSchema
• generateMySqlSchemaOutput

That gives you a stable model of the current schema before you move into runtime synchronization.

Where To Go Next

• Read Team Adoption Guide if you are introducing the library across a team.
• Read Production Workflows Guide if you need a dev/staging/production rollout model.
• Read Legacy Database Onboarding Guide if your schema already exists and you need a low-risk entry path.
• Read Release Operations Guide if you want a consistent release checklist for docs, benchmarks, and engine contract changes.
• Read Plan Artifact Guide if you want a reviewable model for planReflect(...) output in CI or release workflows.
• Read Observability Guide if you want a future-facing event model for tracing planReflect(...) and reflect(...) decisions.
• Read Semantic Change Detection Guide if you want the design rules for rename hints, equivalence, and rebuild avoidance.
• Read Advanced Object Coverage Guide if you want the roadmap for generated columns, deeper defaults, complex indexes, and deeper dependency graphs.
• Read Query Builder Guide if you are focused on fluent SQL.
• Read SQLite Runtime Guide if you are starting from a local SQLite workflow.
• Read PostgreSQL Runtime Guide if you need planning, destructive-change control, or procedural objects.
• Read MySQL Runtime Guide if you need the implemented MySQL runtime surface.
• Read SQL Server Runtime Guide if you are planning the SQL Server support track.
• Read Benchmark Guide if you want current cross-engine performance snapshots.
• Read Benchmark History Guide if you want version-over-version benchmark comparison guidance.
• Read API Map if you want a map of all exported entry points.