@typed-sql/compiler 1.0.0-rc.0 → 1.0.0

package/CHANGELOG.md

@@ -1,5 +1,52 @@
 # @typed-sql/compiler
 
+## 1.0.0
+
+### Major Changes
+
+- 7ca256b: Release the first public typed-sql beta: exact TypeScript 7 row inference from static PostgreSQL and
+  MySQL, versioned schema introspection, application-owned drivers, config-driven grammar plugins,
+  CLI verification, editor language-server integration, versioned diagnostics, bounded parsing, and
+  real-database plus packed-tarball verification.
+
+### Patch Changes
+
+- 1563a7a: Declare and enforce the 1.0 package stability boundary. Core SQL, compiler, schema, config, AST,
+  PostgreSQL, MySQL, and CLI packages form the stable train; the TypeScript preview bridge and
+  language server remain explicitly experimental. Freeze public entrypoints and query type contracts,
+  and remove internal compiler/type helpers from stable package-root exports before 1.0.
+- 16e2475: Prove npm trusted publishing and provenance after the initial registry bootstrap.
+- bd26d6e: Replace potentially expensive parser regular expressions with bounded scanners, tighten editor
+  completion matching, and prevent releases while high-severity CodeQL alerts remain open.
+- 69c7d87: Report `TSQ004` for bare nested templates used as conditional SQL structure and offer an alias-aware
+  language-server quick fix that prefixes the template with `sql.fragment`. Ordinary and nested
+  values remain parameterized across the edit.
+- 3e2c75c: Infer ordered query parameter tuples and let TypeScript reject interpolation values that do not
+  match their SQL context. Dialect contract version 2 adds explicit parameter analysis; unresolved
+  positions remain `unknown`. Add typed nullable predicate composition through `sql.fragment()`,
+  `sql.and()`, `sql.or()`, `sql.where()`, and `sql.append()` while preserving row and parameter tuples.
+  Direct append fragments are grammar-analyzed cumulatively against their static base, so TypeScript
+  rejects fragment interpolation values that disagree with the referenced database columns.
+  Add `sql.empty` and SQL-template-native conditional structural fragments. The compiler analyzes
+  complete branch variants, preserves literal boolean-dependent result rows, and type-checks nested
+  fragment parameters without adding a query-builder DSL. Bound independent structural expansion at
+  64 variants by default, correlate repeated conditions, merge diagnostics and fragment expectations
+  across variants, and fail closed on incompatible contexts. Share indexed catalog and conservative
+  parameter-resolution primitives across grammars, harden cooked-template scanning, and add runtime,
+  resolver, scanner, and structural performance gates.
+- Updated dependencies [eb16de7]
+- Updated dependencies [b6389e4]
+- Updated dependencies [eb16de7]
+- Updated dependencies [b6389e4]
+- Updated dependencies [eb16de7]
+- Updated dependencies [1563a7a]
+- Updated dependencies [9dd6bc4]
+- Updated dependencies [7ca256b]
+- Updated dependencies [16e2475]
+- Updated dependencies [69c7d87]
+- Updated dependencies [3e2c75c]
+  - @typed-sql/core@1.0.0
+
 ## 1.0.0-rc.0
 
 ### Patch Changes

package/README.md

@@ -1,15 +1,16 @@
 # @typed-sql/compiler
 
-The dialect-neutral TypeScript source compiler behind [typed-sql](https://github.com/Lojhan/typed-sql).
-It finds static SQL templates, asks the configured grammar for row and parameter shapes, injects them into
-an in-memory TypeScript program, and preserves source mappings for diagnostics and editor tooling.
+The stable, grammar-neutral TypeScript source compiler behind
+[typed-sql](https://github.com/Lojhan/typed-sql). It finds static SQL templates, asks the configured
+grammar for row and parameter shapes, creates an in-memory TypeScript overlay, and preserves source
+mappings for diagnostics and editor tooling.
 
 ```sh
-pnpm add @typed-sql/compiler@next
+pnpm add @typed-sql/compiler
 ```
 
 ```ts
-import { checkFile, compileSource, extractStaticQueries, mapSqlRange } from "@typed-sql/compiler";
+import { compileSource } from "@typed-sql/compiler";
 import { postgres } from "@typed-sql/postgres";
 
 const result = compileSource({
@@ -19,38 +20,12 @@ const result = compileSource({
 });
 ```
 
-`compileSource` does not branch on PostgreSQL, MySQL, package names, or database drivers. It only
-consumes the public `DialectPlugin` contract from `@typed-sql/core`. Unsupported, dynamic, invalid,
-or ambiguous SQL remains a diagnostic or an `unknown` position—never `any`. The resulting overlay
-uses `Query<Row, readonly [Param1, Param2, ...]>`, which lets TypeScript report incorrect `${...}`
-values at their original source locations.
+`compileSource` consumes only `DialectPlugin`; it does not branch on a database, grammar package,
+or driver. Its public options include the structural-variant bound used for conditional fragments.
+Application projects normally use the compiler through `typed-sql check` or the language server.
 
-Direct `sql.append(base, ...fragments)` expressions are analyzed cumulatively. The compiler resolves
-the statically bound base query, adds each visible `sql.fragment` in source order, and injects the
-grammar-derived parameter tuple into that fragment. Composed values are therefore checked against
-their referenced columns even when a preceding fragment introduces structure such as
-`WHERE 1 = 1`. Indirect function-returned fragments and arbitrary mutable collections remain at the
-core runtime's parameter-safe boundary rather than being guessed.
-
-Structural fragment interpolations inside a complete `sql` template are expanded as correlated,
-finite branches. The compiler analyzes each resulting complete SQL statement, emits a conditional
-row for generic boolean property selections, and injects expected parameter types into nested
-fragments. `sql.empty` represents the absent branch without turning it into a driver parameter.
-The expansion is a grammar-neutral intermediate representation: SQL parsing and resolution still
-belong exclusively to `DialectPlugin.analyze()`.
-
-`compileSource` accepts `maxStructuralVariants`, defaulting to 64. The compiler counts independent
-conditions and returns `TSQ003` before invoking the grammar when the bound would be exceeded.
-Repeated uses of the same condition are correlated and do not multiply the branch count. A shared
-fragment that receives incompatible parameter expectations across valid branches fails closed with
-`TSQ205`.
-
-Before grammar analysis, the scanner rejects an untagged template paired with `sql.empty` or a
-trusted fragment as `TSQ004`. This produces one focused source diagnostic instead of a downstream
-SQL parse error. Ordinary value templates remain parameters; the compiler never interprets their
-runtime strings as SQL structure.
-
-Application projects normally use this through `typed-sql check` or the language server. It is
-public for grammar, editor, and build-tool integrations.
+Read [Architecture](https://github.com/Lojhan/typed-sql/blob/main/docs/concepts/architecture.md),
+[Compose conditional SQL](https://github.com/Lojhan/typed-sql/blob/main/docs/guides/composition.md), and
+[Inference and safety](https://github.com/Lojhan/typed-sql/blob/main/docs/concepts/type-safety.md).
 
 MIT © typed-sql contributors

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typed-sql/compiler",
-  "version": "1.0.0-rc.0",
+  "version": "1.0.0",
   "description": "Dialect-neutral TypeScript source extraction and typed SQL compilation.",
   "license": "MIT",
   "author": "Lojhan",
@@ -36,7 +36,7 @@
     ".": "./dist/packages/compiler/src/index.js"
   },
   "dependencies": {
-    "@typed-sql/core": "1.0.0-rc.0"
+    "@typed-sql/core": "1.0.0"
   },
   "scripts": {
     "test": "poku test --reporter=compact --enforce",