@triptease/sql-template 0.23.24 → 0.35.6

package/Expression.d.ts

@@ -1,2 +1,24 @@
-export declare class Expression {
+/**
+ * Brand used to identify expressions at runtime.
+ *
+ * It is registered with `Symbol.for` so that expressions created by a different copy of this package
+ * (e.g. a duplicated install, or a different version pulled in by an adapter) are still recognised,
+ * which `instanceof` cannot do. It is a symbol rather than a string field so that untrusted data
+ * (e.g. the output of `JSON.parse`) can never masquerade as an expression.
+ */
+export declare const kind: unique symbol;
+/** The kinds of expression understood by adapters. Adapters must throw on anything else. */
+export type Kind = 'text' | 'identifier' | 'value' | 'template';
+export interface Expression {
+    readonly [kind]: Kind;
 }
+/**
+ * Base class of all expressions. Every concrete expression defines its `kind` brand on its prototype.
+ * Subclassing it outside this package is not supported: such instances have no brand and are rejected
+ * by `SQL`, `value` and `template` (compose the built-in expressions instead).
+ */
+export declare abstract class Expression {
+}
+/** The kind of `value` if it is an expression (from any copy of this package), otherwise `undefined`. */
+export declare function kindOf(value: unknown): string | undefined;
+export declare function isExpression(value: unknown): value is Expression;

package/Expression.js

@@ -1,7 +1,27 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Expression = void 0;
-class Expression {
+/**
+ * Brand used to identify expressions at runtime.
+ *
+ * It is registered with `Symbol.for` so that expressions created by a different copy of this package
+ * (e.g. a duplicated install, or a different version pulled in by an adapter) are still recognised,
+ * which `instanceof` cannot do. It is a symbol rather than a string field so that untrusted data
+ * (e.g. the output of `JSON.parse`) can never masquerade as an expression.
+ */
+export const kind = Symbol.for('@triptease/sql-template/kind');
+/**
+ * Base class of all expressions. Every concrete expression defines its `kind` brand on its prototype.
+ * Subclassing it outside this package is not supported: such instances have no brand and are rejected
+ * by `SQL`, `value` and `template` (compose the built-in expressions instead).
+ */
+export class Expression {
+}
+/** The kind of `value` if it is an expression (from any copy of this package), otherwise `undefined`. */
+export function kindOf(value) {
+    if (typeof value !== 'object' || value === null)
+        return undefined;
+    const k = value[kind];
+    return typeof k === 'string' ? k : undefined;
+}
+export function isExpression(value) {
+    return kindOf(value) !== undefined;
 }
-exports.Expression = Expression;
 //# sourceMappingURL=Expression.js.map

package/Expression.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Expression.js","sourceRoot":"","sources":["../src/Expression.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,IAAI,GAAkB,MAAM,CAAC,GAAG,CAAC,8BAA8B,CAAC,CAAC;AAS9E;;;;GAIG;AACH,MAAM,OAAgB,UAAU;CAC/B;AAED,yGAAyG;AACzG,MAAM,UAAU,MAAM,CAAC,KAAc;IACjC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,SAAS,CAAC;IAClE,MAAM,CAAC,GAAa,KAA8B,CAAC,IAAI,CAAC,CAAC;IACzD,OAAO,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AACjD,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,KAAc;IACvC,OAAO,MAAM,CAAC,KAAK,CAAC,KAAK,SAAS,CAAC;AACvC,CAAC","sourcesContent":["/**\n * Brand used to identify expressions at runtime.\n *\n * It is registered with `Symbol.for` so that expressions created by a different copy of this package\n * (e.g. a duplicated install, or a different version pulled in by an adapter) are still recognised,\n * which `instanceof` cannot do. It is a symbol rather than a string field so that untrusted data\n * (e.g. the output of `JSON.parse`) can never masquerade as an expression.\n */\nexport const kind: unique symbol = Symbol.for('@triptease/sql-template/kind');\n\n/** The kinds of expression understood by adapters. Adapters must throw on anything else. */\nexport type Kind = 'text' | 'identifier' | 'value' | 'template';\n\nexport interface Expression {\n    readonly [kind]: Kind;\n}\n\n/**\n * Base class of all expressions. Every concrete expression defines its `kind` brand on its prototype.\n * Subclassing it outside this package is not supported: such instances have no brand and are rejected\n * by `SQL`, `value` and `template` (compose the built-in expressions instead).\n */\nexport abstract class Expression {\n}\n\n/** The kind of `value` if it is an expression (from any copy of this package), otherwise `undefined`. */\nexport function kindOf(value: unknown): string | undefined {\n    if (typeof value !== 'object' || value === null) return undefined;\n    const k: unknown = (value as { [kind]?: unknown })[kind];\n    return typeof k === 'string' ? k : undefined;\n}\n\nexport function isExpression(value: unknown): value is Expression {\n    return kindOf(value) !== undefined;\n}\n"]}

package/Identifier.d.ts

@@ -1,8 +1,17 @@
-import { Expression } from "./Expression";
-import { Template } from "./Template";
+import { Expression, kind } from "./Expression.js";
+import { Template } from "./Template.js";
+export interface Identifier {
+    readonly [kind]: 'identifier';
+}
+/** A dynamic identifier (table, column, ...) that adapters escape. */
 export declare class Identifier extends Expression {
     readonly identifier: string;
     constructor(identifier: string);
 }
+export declare function isIdentifier(value: unknown): value is Identifier;
 export declare function id(identifier: string): Identifier;
-export declare function ids(identifiers: any[], separator?: string): Template;
+/**
+ * Multiple identifiers separated by `separator` (default `text(', ')`).
+ * The separator is an Expression so any raw SQL is explicit at the call site.
+ */
+export declare function ids(identifiers: readonly string[], separator?: Expression): Template;

package/Identifier.js

@@ -1,22 +1,31 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ids = exports.id = exports.Identifier = void 0;
-const Expression_1 = require("./Expression");
-const Template_1 = require("./Template");
-const Text_1 = require("./Text");
-class Identifier extends Expression_1.Expression {
+import { Expression, kind, kindOf } from "./Expression.js";
+import { template, Template } from "./Template.js";
+import { text } from "./Text.js";
+import { separated } from "./separated.js";
+/** A dynamic identifier (table, column, ...) that adapters escape. */
+export class Identifier extends Expression {
+    identifier;
     constructor(identifier) {
         super();
+        if (typeof identifier !== 'string')
+            throw new TypeError(`Identifier must be a string but was ${typeof identifier}`);
         this.identifier = identifier;
+        if (new.target === Identifier)
+            Object.freeze(this);
     }
 }
-exports.Identifier = Identifier;
-function id(identifier) {
+Object.defineProperty(Identifier.prototype, kind, { value: 'identifier' });
+export function isIdentifier(value) {
+    return kindOf(value) === 'identifier';
+}
+export function id(identifier) {
     return new Identifier(identifier);
 }
-exports.id = id;
-function ids(identifiers, separator = ', ') {
-    return (0, Template_1.template)(...identifiers.flatMap((v, i) => i > 0 ? [(0, Text_1.text)(separator), id(v)] : [id(v)]));
+/**
+ * Multiple identifiers separated by `separator` (default `text(', ')`).
+ * The separator is an Expression so any raw SQL is explicit at the call site.
+ */
+export function ids(identifiers, separator = text(', ')) {
+    return template(...separated(identifiers.map(id), separator));
 }
-exports.ids = ids;
 //# sourceMappingURL=Identifier.js.map

package/Identifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Identifier.js","sourceRoot":"","sources":["../src/Identifier.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAE,IAAI,EAAE,MAAM,EAAC,MAAM,iBAAiB,CAAC;AACzD,OAAO,EAAC,QAAQ,EAAE,QAAQ,EAAC,MAAM,eAAe,CAAC;AACjD,OAAO,EAAC,IAAI,EAAC,MAAM,WAAW,CAAC;AAC/B,OAAO,EAAC,SAAS,EAAC,MAAM,gBAAgB,CAAC;AAMzC,sEAAsE;AACtE,MAAM,OAAO,UAAW,SAAQ,UAAU;IAC7B,UAAU,CAAS;IAE5B,YAAY,UAAkB;QAC1B,KAAK,EAAE,CAAC;QACR,IAAI,OAAO,UAAU,KAAK,QAAQ;YAAE,MAAM,IAAI,SAAS,CAAC,uCAAuC,OAAO,UAAU,EAAE,CAAC,CAAC;QACpH,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,IAAI,MAAM,KAAK,UAAU;YAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACvD,CAAC;CACJ;AAED,MAAM,CAAC,cAAc,CAAC,UAAU,CAAC,SAAS,EAAE,IAAI,EAAE,EAAC,KAAK,EAAE,YAAY,EAAC,CAAC,CAAC;AAEzE,MAAM,UAAU,YAAY,CAAC,KAAc;IACvC,OAAO,MAAM,CAAC,KAAK,CAAC,KAAK,YAAY,CAAC;AAC1C,CAAC;AAED,MAAM,UAAU,EAAE,CAAC,UAAkB;IACjC,OAAO,IAAI,UAAU,CAAC,UAAU,CAAC,CAAC;AACtC,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,GAAG,CAAC,WAA8B,EAAE,SAAS,GAAe,IAAI,CAAC,IAAI,CAAC;IAClF,OAAO,QAAQ,CAAC,GAAG,SAAS,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC;AAClE,CAAC","sourcesContent":["import {Expression, kind, kindOf} from \"./Expression.js\";\nimport {template, Template} from \"./Template.js\";\nimport {text} from \"./Text.js\";\nimport {separated} from \"./separated.js\";\n\nexport interface Identifier {\n    readonly [kind]: 'identifier';\n}\n\n/** A dynamic identifier (table, column, ...) that adapters escape. */\nexport class Identifier extends Expression {\n    readonly identifier: string;\n\n    constructor(identifier: string) {\n        super();\n        if (typeof identifier !== 'string') throw new TypeError(`Identifier must be a string but was ${typeof identifier}`);\n        this.identifier = identifier;\n        if (new.target === Identifier) Object.freeze(this);\n    }\n}\n\nObject.defineProperty(Identifier.prototype, kind, {value: 'identifier'});\n\nexport function isIdentifier(value: unknown): value is Identifier {\n    return kindOf(value) === 'identifier';\n}\n\nexport function id(identifier: string): Identifier {\n    return new Identifier(identifier);\n}\n\n/**\n * Multiple identifiers separated by `separator` (default `text(', ')`).\n * The separator is an Expression so any raw SQL is explicit at the call site.\n */\nexport function ids(identifiers: readonly string[], separator: Expression = text(', ')): Template {\n    return template(...separated(identifiers.map(id), separator));\n}\n"]}

package/README.md

@@ -1,56 +1,200 @@
-# Sql Template
-
-This is yet another SQL tagged template for Typescript/Javascript
-
-## Why another library?
-
-* Typescript first
-* Functional/Immutable
-* Super simple implementation (the main SQL function is [3 lines of code](https://github.com/triptease/sql-template/blob/master/sql-template/src/SQL.ts#L5))
-* Full escaping of identifiers and values
-* Plugable to any DB (currently only Postgres @triptease\sql-template-postgres )
-* Automatic support for prepareStatement naming (Postgres)
-
-## Installation
-
-```shell
-npm install @triptease/sql-template @triptease/sql-template-postgres
-```
-
-## Usage
-
-```javascript
-import {SQL, id} from "@triptease/sql-template";
-import {statement} from "@triptease/sql-template-postgres";
-
-client.query(statement(SQL`select * from ${id(table)} where name = ${name}`));
-```
-
-## Cheatsheet
-
-### Core (@triptease/sql-template) 
-
-| function                                       | Description                                                          |
-|------------------------------------------------|----------------------------------------------------------------------|
-| `SQL`                                          | The main function to create tagged templates for SQL (*DB agnostic*) |
-| `text` (alias `raw`)                           | Input raw SQL without any escaping (*use with care*)                 |
- | `id` / `ids`                                   | Input dynamic identifiers into SQL (*escaped as needed*)             |
- | `value` (optional) / `values` (alias `spread`) | Input one or more values into SQL (*escaped as needed*)              |
-
-
-### Postgres (@triptease/sql-template-postgres)
-
-| function                                       | Description                                                         |
-|------------------------------------------------|---------------------------------------------------------------------|
-| `statement`                                    | Converts DB agnostic `SQL` template into postgres statement         |
-| `prepareStatement`                             | Converts DB agnostic `SQL` template into postgres prepare statement |
-| `debugQuery`                                   | Used to debug a query (*use with care*)                             |
-
-*use with care -> Used incorrectly you can open yourself up to SQL injection*
-
-
-### Extending
-
-It is incredibly simple to extend to other DBs, have a look at the [postgres implementation](https://github.com/triptease/sql-template/blob/master/sql-template-postgres/src/index.ts#L17). 
-
-
+# Sql Template
+
+This is yet another SQL tagged template for Typescript/Javascript
+
+## Why another library?
+
+* Typescript first
+* Functional/Immutable
+* Super simple implementation (see [SQL.ts](https://github.com/triptease/sql-template/blob/master/sql-template/src/SQL.ts))
+* Full escaping of identifiers and values
+* Plugable to any DB (currently Postgres via `@triptease/sql-template-postgres` with `pg`)
+* Automatic support for prepareStatement naming (Postgres)
+
+## Installation
+
+```shell
+npm install @triptease/sql-template @triptease/sql-template-postgres
+# or
+bun add @triptease/sql-template @triptease/sql-template-postgres
+```
+
+Both packages are plain ESM JavaScript with type declarations, so they work in Node and Bun.
+`@triptease/sql-template` has no dependencies and `@triptease/sql-template-postgres` depends only on it
+(it does not depend on `pg`; bring your own driver). In Node they can also be loaded with `require()`
+(Node 20.19+/22.12+, which can `require()` ES modules).
+
+## Usage
+
+### Node with [pg](https://node-postgres.com/)
+
+```typescript
+import pg from "pg";
+import {SQL, id, values} from "@triptease/sql-template";
+import {statement, prepareStatement} from "@triptease/sql-template-postgres";
+
+const pool = new pg.Pool();
+const {rows} = await pool.query(statement(SQL`select * from ${id(table)} where name = ${name}`));
+// SQL: select * from "users" where name = $1   values: ['Dan']
+
+// named prepared statement (name defaults to a hash of the SQL)
+await pool.query(prepareStatement(SQL`select * from users where id in (${values(userIds)})`));
+```
+
+### Bun
+
+If you only target Bun, its built-in [`sql`](https://bun.com/docs/api/sql) tagged template already binds values
+and escapes identifiers, so you probably don't need this library. Use it in Bun when your query code also has to
+run on Node with `pg`, or when you want queries as plain immutable values you can build, test and log
+(`debugQuery`) without a connection.
+
+### Composing
+
+```typescript
+import {SQL, id, ids, text, values} from "@triptease/sql-template";
+
+const where = SQL`where ${id('name')} = ${name}`;
+const query = SQL`select ${ids(['id', 'name'])} from users ${where}`; // templates nest
+const either = SQL`select * from users where ${values([a, b], text(' or '))}`; // explicit raw separator
+```
+
+Templates are immutable (frozen) and flat. Expressions are identified by a `Symbol.for` brand rather than
+`instanceof`, so templates built by a different copy of `@triptease/sql-template` (e.g. two installed
+versions) still work, while plain data (such as parsed JSON) can never be mistaken for SQL.
+
+## Cheatsheet
+
+### Core (@triptease/sql-template)
+
+| function                                       | Description                                                                                 |
+|------------------------------------------------|---------------------------------------------------------------------------------------------|
+| `SQL`                                          | The main function to create tagged templates for SQL (*DB agnostic*)                        |
+| `text` (alias `raw`)                           | Input raw SQL without any escaping (*use with care*)                                        |
+| `id` / `ids(names, separator?)`                | Input dynamic identifiers into SQL (*escaped as needed*)                                    |
+| `value` (optional) / `values(list, separator?)` (alias `spread`) | Input one or more values into SQL (*bound as parameters*)                 |
+| `template`                                     | Combine expressions into a (flattened, frozen) template                                     |
+| `isExpression` / `isText` / `isIdentifier` / `isValue` / `isTemplate` / `kindOf` | Type guards based on the expression brand (for adapters) |
+
+`separator` is an Expression and defaults to `text(', ')`.
+
+### Postgres (@triptease/sql-template-postgres)
+
+| function                                       | Description                                                          |
+|------------------------------------------------|----------------------------------------------------------------------|
+| `statement`                                    | Converts DB agnostic `SQL` template into a postgres statement (`pg`) |
+| `prepareStatement`                             | Converts DB agnostic `SQL` template into a named prepared statement (`pg`) |
+| `escapeIdentifier` / `escapeLiteral`           | Postgres identifier and string literal escaping (ported from `pg`)   |
+| `debugQuery`                                   | Renders a template with values inlined, for debugging (*see below*) |
+
+*use with care -> Used incorrectly you can open yourself up to SQL injection*
+
+`debugQuery` escapes every value (strings, numbers, booleans, null, Dates, Buffers, arrays and objects), but
+it is meant for logging: execute queries with `statement`/`prepareStatement` so values are bound as
+parameters. Inlined literals are not always typed the way parameters are (e.g. arrays become array literal
+strings and objects JSON strings, which need a cast in some contexts). Dates are inlined as UTC ISO strings, so for
+`timestamp` (without time zone) or text targets the output only matches what `pg` executes when the process runs
+with `TZ=UTC`.
+
+## Breaking changes (since the pg-only releases)
+
+* The `separator` of `values`/`spread`/`ids` is now an Expression: replace `values(xs, ' or ')` with
+  `values(xs, text(' or '))`. Passing a string throws a `TypeError` (it used to be inserted as raw SQL).
+* `@triptease/sql-template-postgres` no longer depends on `pg`; its `QueryConfig` is a local type
+  that is structurally compatible with pg's.
+* Adapters throw on expressions they do not understand instead of silently dropping them, and SQL with an
+  invalid escape sequence (e.g. ``SQL`\u` ``) throws instead of producing the text `undefined`.
+* Public types use `unknown` instead of `any`; `ids` takes `string[]`.
+* The packages are ESM only (they used to be CommonJS):
+  * `require()` needs Node 20.19+/22.12+ (older Node versions can only `import` them).
+  * TypeScript consumers need `"module"`/`"moduleResolution"` set to `nodenext` (or `node20`) or `bundler`.
+    A CommonJS project using `node16` (or `nodenext` before TypeScript 5.8) gets error TS1479; switch to one of
+    those settings or load the packages with `import()`.
+  * Only the package roots are exported: deep imports such as `@triptease/sql-template/Text` fail with
+    `ERR_PACKAGE_PATH_NOT_EXPORTED`. Import everything from `@triptease/sql-template` /
+    `@triptease/sql-template-postgres`.
+* `Expression` is abstract and subclassing it is not supported: an instance of your own subclass is rejected with
+  a `TypeError` (compose `SQL`/`text`/`id`/`value`/`template` instead).
+* `debugQuery` output changed: `null`/`undefined` render as `NULL`, booleans as `TRUE`/`FALSE`, negative numbers
+  are parenthesised, `NaN`/`Infinity` are quoted, and Dates, Buffers, arrays and objects are rendered as escaped
+  literals. Do not parse or compare its output.
+* A `Template` built directly with `new Template([...])` now keeps the values of nested templates (they used to be
+  dropped).
+
+## Extending
+
+It is simple to extend to other DBs: switch on `kindOf(expression)` (`'text'`, `'identifier'`, `'value'`,
+`'template'`) and throw on anything else. Have a look at the
+[postgres implementation](https://github.com/triptease/sql-template/blob/master/sql-template-postgres/src/statement.ts).
+
+## Development
+
+Tool versions (node, bun) are pinned in `mise.toml`. Install [mise](https://mise.jdx.dev/getting-started.html), then:
+
+```shell
+mise install   # installs the pinned node and bun
+./run          # install deps, clean, build (tsc --build), typecheck and test (bun test)
+```
+
+The repo is a bun workspace: each package has a published `src/package.json` (runtime dependencies only)
+and a private `test/package.json` (test dependencies). Tests import the packages by name.
+
+The postgres integration tests (`sql-template-postgres/test/integration.test.ts`) run real queries through
+`pg`. They need a database:
+
+```shell
+DATABASE_URL=postgres://postgres:postgres@localhost:5432/postgres ./run
+```
+
+Without `DATABASE_URL` they are skipped locally (with a warning) but fail when `CI=true`; the GitHub Actions
+test job provides a `postgres:18` service.
+
+## Releasing
+
+Every push to `triptease/sql-template` that passes the `test` job runs the `publish` job in
+[`.github/workflows/build.yml`](.github/workflows/build.yml), which runs `scripts/release.ts`:
+
+* Version: `0.<git rev-list --count HEAD>.<GITHUB_RUN_NUMBER>`; dist-tag `latest` on `master`, `dev` on other branches.
+* It does a clean `tsc --build` (without declaration maps, as the `.ts` sources are not published), then
+  writes `<pkg>/dist/package.json` from `<pkg>/src/package.json` (version
+  stamped, `workspace:*` replaced by that version, `main`/`types`/`exports` pointing at the `.js`/`.d.ts`
+  files, explicit `files`) and copies this README next to it. The `dist` directory is what gets published, so
+  import paths never contain `src/` or `dist/`. It fails if any `workspace:` range is left.
+* It publishes core first, then postgres, with `npm publish <pkg>/dist`:
+  * to **GitHub Packages** (`npm.pkg.github.com`) on every run, using the workflow's `GITHUB_TOKEN`;
+  * to **npmjs** only when the repo variable `NPM_PUBLISH` is `true`, with `--access public --provenance`,
+    authenticated by npm Trusted Publishing (OIDC), or by an `NPM_TOKEN` secret if one exists.
+* Versions that are already on a registry are skipped, so a failed run can simply be re-run.
+* The staged `dist` directories are kept as the `dist` artifact of the workflow run.
+
+Check what would be published without uploading anything (`npm publish --dry-run`; add `NPM_PUBLISH=true`
+to include npmjs):
+
+```shell
+./run release --dry-run
+```
+
+`./run ci` runs the full build and tests, then the release script.
+
+### One-off setup (needs an npm org admin and a GitHub repo admin)
+
+1. On npmjs.com, for **each** of `@triptease/sql-template` and `@triptease/sql-template-postgres`:
+   Settings → Trusted Publisher → GitHub Actions, organization `triptease`, repository `sql-template`,
+   workflow filename `build.yml`, environment empty. The workflow filename is part of the trust
+   relationship, so do not rename `build.yml`. Once it works, npm recommends disallowing token publishing
+   for the packages (Settings → Publishing access).
+2. In the GitHub repo, set the Actions variable `NPM_PUBLISH` to `true` (Settings → Secrets and variables →
+   Actions → Variables). Until then npmjs publishing is skipped and only GitHub Packages is published.
+   (Alternative to step 1: add an `NPM_TOKEN` repo secret with publish rights; the publish step uses it if set.)
+3. GitHub Packages: after the first publish, check both packages under the org's Packages page, make sure
+   they are linked to this repository and set their visibility to public if they should be visible
+   outside the org.
+
+### Installing from GitHub Packages
+
+npmjs is the main channel. Installing from GitHub Packages needs authentication even for public packages:
+a token with `read:packages` and an `.npmrc` like
+
+```ini
+@triptease:registry=https://npm.pkg.github.com
+//npm.pkg.github.com/:_authToken=${GITHUB_TOKEN}
+```

package/SQL.d.ts

@@ -1,2 +1,2 @@
-import { Template } from "./Template";
-export declare function SQL(chunks: TemplateStringsArray, ...values: any[]): Template;
+import { Template } from "./Template.js";
+export declare function SQL(chunks: TemplateStringsArray, ...values: unknown[]): Template;

package/SQL.js

@@ -1,15 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SQL = void 0;
-const Template_1 = require("./Template");
-const Text_1 = require("./Text");
-const Value_1 = require("./Value");
-function SQL(chunks, ...values) {
-    return (0, Template_1.template)(...chunks.flatMap((chunk, index) => {
+import { template, Template } from "./Template.js";
+import { text } from "./Text.js";
+import { value } from "./Value.js";
+export function SQL(chunks, ...values) {
+    return template(...chunks.flatMap((chunk, index) => {
+        if (typeof chunk !== 'string') {
+            throw new SyntaxError(`Invalid escape sequence in SQL template: ${JSON.stringify(chunks.raw?.[index])}`);
+        }
         if (index > (values.length - 1))
-            return [(0, Text_1.text)(chunk)];
-        return [(0, Text_1.text)(chunk), (0, Value_1.value)(values[index])];
+            return [text(chunk)];
+        return [text(chunk), value(values[index])];
     }));
 }
-exports.SQL = SQL;
 //# sourceMappingURL=SQL.js.map

package/SQL.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SQL.js","sourceRoot":"","sources":["../src/SQL.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,QAAQ,EAAE,QAAQ,EAAC,MAAM,eAAe,CAAC;AACjD,OAAO,EAAC,IAAI,EAAC,MAAM,WAAW,CAAC;AAC/B,OAAO,EAAC,KAAK,EAAC,MAAM,YAAY,CAAC;AAEjC,MAAM,UAAU,GAAG,CAAC,MAA4B,EAAE,GAAG,MAAiB;IAClE,OAAO,QAAQ,CAAC,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;QAC/C,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC5B,MAAM,IAAI,WAAW,CAAC,4CAA4C,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;QAC7G,CAAC;QACD,IAAI,KAAK,GAAG,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;YAAE,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;QACtD,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IAC/C,CAAC,CAAC,CAAC,CAAC;AACR,CAAC","sourcesContent":["import {template, Template} from \"./Template.js\";\nimport {text} from \"./Text.js\";\nimport {value} from \"./Value.js\";\n\nexport function SQL(chunks: TemplateStringsArray, ...values: unknown[]): Template {\n    return template(...chunks.flatMap((chunk, index) => {\n        if (typeof chunk !== 'string') {\n            throw new SyntaxError(`Invalid escape sequence in SQL template: ${JSON.stringify(chunks.raw?.[index])}`);\n        }\n        if (index > (values.length - 1)) return [text(chunk)];\n        return [text(chunk), value(values[index])];\n    }));\n}\n"]}

package/Template.d.ts

@@ -1,6 +1,15 @@
-import { Expression } from "./Expression";
+import { Expression, kind } from "./Expression.js";
+export interface Template {
+    readonly [kind]: 'template';
+}
+/**
+ * A sequence of expressions. Construction always normalises: nested templates are flattened
+ * (recursively) and empty text is removed, so adapters only ever see Text, Identifier and Value.
+ * Templates are frozen.
+ */
 export declare class Template extends Expression {
     readonly expressions: ReadonlyArray<Expression>;
     constructor(expressions: ReadonlyArray<Expression>);
 }
+export declare function isTemplate(value: unknown): value is Template;
 export declare function template(...expressions: Expression[]): Template;

package/Template.js

@@ -1,23 +1,38 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.template = exports.Template = void 0;
-const Expression_1 = require("./Expression");
-const Text_1 = require("./Text");
-class Template extends Expression_1.Expression {
+import { Expression, isExpression, kind, kindOf } from "./Expression.js";
+import { invalidExpression } from "./invalid.js";
+function flatten(expressions, result) {
+    for (const e of expressions) {
+        if (!isExpression(e))
+            throw invalidExpression(e, 'Template');
+        const k = kindOf(e);
+        if (k === 'template')
+            flatten(e.expressions, result);
+        else if (k === 'text' && e.text === '')
+            continue;
+        else
+            result.push(e);
+    }
+    return result;
+}
+/**
+ * A sequence of expressions. Construction always normalises: nested templates are flattened
+ * (recursively) and empty text is removed, so adapters only ever see Text, Identifier and Value.
+ * Templates are frozen.
+ */
+export class Template extends Expression {
+    expressions;
     constructor(expressions) {
         super();
-        this.expressions = expressions;
+        this.expressions = Object.freeze(flatten(expressions, []));
+        if (new.target === Template)
+            Object.freeze(this);
     }
 }
-exports.Template = Template;
-function template(...expressions) {
-    return new Template(expressions.flatMap(e => {
-        if (e instanceof Text_1.Text && e.text === '')
-            return [];
-        if (e instanceof Template)
-            return e.expressions;
-        return [e];
-    }));
+Object.defineProperty(Template.prototype, kind, { value: 'template' });
+export function isTemplate(value) {
+    return kindOf(value) === 'template';
+}
+export function template(...expressions) {
+    return new Template(expressions);
 }
-exports.template = template;
 //# sourceMappingURL=Template.js.map

package/Template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Template.js","sourceRoot":"","sources":["../src/Template.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,EAAC,MAAM,iBAAiB,CAAC;AACvE,OAAO,EAAC,iBAAiB,EAAC,MAAM,cAAc,CAAC;AAE/C,SAAS,OAAO,CAAC,WAA+B,EAAE,MAAoB;IAClE,KAAK,MAAM,CAAC,IAAI,WAAW,EAAE,CAAC;QAC1B,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC;YAAE,MAAM,iBAAiB,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC;QAC7D,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QACpB,IAAI,CAAC,KAAK,UAAU;YAAE,OAAO,CAAE,CAAc,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;aAC9D,IAAI,CAAC,KAAK,MAAM,IAAK,CAAwB,CAAC,IAAI,KAAK,EAAE;YAAE,SAAS;;YACpE,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACxB,CAAC;IACD,OAAO,MAAM,CAAC;AAClB,CAAC;AAMD;;;;GAIG;AACH,MAAM,OAAO,QAAS,SAAQ,UAAU;IAC3B,WAAW,CAA4B;IAEhD,YAAY,WAAsC;QAC9C,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC,CAAC;QAC3D,IAAI,IAAI,MAAM,KAAK,QAAQ;YAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACrD,CAAC;CACJ;AAED,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,SAAS,EAAE,IAAI,EAAE,EAAC,KAAK,EAAE,UAAU,EAAC,CAAC,CAAC;AAErE,MAAM,UAAU,UAAU,CAAC,KAAc;IACrC,OAAO,MAAM,CAAC,KAAK,CAAC,KAAK,UAAU,CAAC;AACxC,CAAC;AAED,MAAM,UAAU,QAAQ,CAAC,GAAG,WAAyB;IACjD,OAAO,IAAI,QAAQ,CAAC,WAAW,CAAC,CAAC;AACrC,CAAC","sourcesContent":["import {Expression, isExpression, kind, kindOf} from \"./Expression.js\";\nimport {invalidExpression} from \"./invalid.js\";\n\nfunction flatten(expressions: readonly unknown[], result: Expression[]): Expression[] {\n    for (const e of expressions) {\n        if (!isExpression(e)) throw invalidExpression(e, 'Template');\n        const k = kindOf(e);\n        if (k === 'template') flatten((e as Template).expressions, result);\n        else if (k === 'text' && (e as { text?: unknown }).text === '') continue;\n        else result.push(e);\n    }\n    return result;\n}\n\nexport interface Template {\n    readonly [kind]: 'template';\n}\n\n/**\n * A sequence of expressions. Construction always normalises: nested templates are flattened\n * (recursively) and empty text is removed, so adapters only ever see Text, Identifier and Value.\n * Templates are frozen.\n */\nexport class Template extends Expression {\n    readonly expressions: ReadonlyArray<Expression>;\n\n    constructor(expressions: ReadonlyArray<Expression>) {\n        super();\n        this.expressions = Object.freeze(flatten(expressions, []));\n        if (new.target === Template) Object.freeze(this);\n    }\n}\n\nObject.defineProperty(Template.prototype, kind, {value: 'template'});\n\nexport function isTemplate(value: unknown): value is Template {\n    return kindOf(value) === 'template';\n}\n\nexport function template(...expressions: Expression[]): Template {\n    return new Template(expressions);\n}\n"]}

package/Text.d.ts

@@ -1,7 +1,13 @@
-import { Expression } from "./Expression";
+import { Expression, kind } from "./Expression.js";
+export interface Text {
+    readonly [kind]: 'text';
+}
+/** Raw SQL, inserted verbatim without any escaping. */
 export declare class Text extends Expression {
     readonly text: string;
     constructor(text: string);
 }
+export declare function isText(value: unknown): value is Text;
+/** Raw SQL, inserted verbatim without any escaping (*use with care*). */
 export declare function text(text: string): Text;
 export declare const raw: typeof text;

package/Text.js

@@ -1,17 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.raw = exports.text = exports.Text = void 0;
-const Expression_1 = require("./Expression");
-class Text extends Expression_1.Expression {
+import { Expression, kind, kindOf } from "./Expression.js";
+/** Raw SQL, inserted verbatim without any escaping. */
+export class Text extends Expression {
+    text;
     constructor(text) {
         super();
+        if (typeof text !== 'string')
+            throw new TypeError(`Text must be a string but was ${typeof text}`);
         this.text = text;
+        if (new.target === Text)
+            Object.freeze(this);
     }
 }
-exports.Text = Text;
-function text(text) {
+Object.defineProperty(Text.prototype, kind, { value: 'text' });
+export function isText(value) {
+    return kindOf(value) === 'text';
+}
+/** Raw SQL, inserted verbatim without any escaping (*use with care*). */
+export function text(text) {
     return new Text(text);
 }
-exports.text = text;
-exports.raw = text;
+export const raw = text;
 //# sourceMappingURL=Text.js.map

package/Text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Text.js","sourceRoot":"","sources":["../src/Text.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAE,IAAI,EAAE,MAAM,EAAC,MAAM,iBAAiB,CAAC;AAMzD,uDAAuD;AACvD,MAAM,OAAO,IAAK,SAAQ,UAAU;IACvB,IAAI,CAAS;IAEtB,YAAY,IAAY;QACpB,KAAK,EAAE,CAAC;QACR,IAAI,OAAO,IAAI,KAAK,QAAQ;YAAE,MAAM,IAAI,SAAS,CAAC,iCAAiC,OAAO,IAAI,EAAE,CAAC,CAAC;QAClG,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,IAAI,MAAM,KAAK,IAAI;YAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACjD,CAAC;CACJ;AAED,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,EAAE,EAAC,KAAK,EAAE,MAAM,EAAC,CAAC,CAAC;AAE7D,MAAM,UAAU,MAAM,CAAC,KAAc;IACjC,OAAO,MAAM,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC;AACpC,CAAC;AAED,yEAAyE;AACzE,MAAM,UAAU,IAAI,CAAC,IAAY;IAC7B,OAAO,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC;AAC1B,CAAC;AAED,MAAM,CAAC,MAAM,GAAG,GAAgB,IAAI,CAAC","sourcesContent":["import {Expression, kind, kindOf} from \"./Expression.js\";\n\nexport interface Text {\n    readonly [kind]: 'text';\n}\n\n/** Raw SQL, inserted verbatim without any escaping. */\nexport class Text extends Expression {\n    readonly text: string;\n\n    constructor(text: string) {\n        super();\n        if (typeof text !== 'string') throw new TypeError(`Text must be a string but was ${typeof text}`);\n        this.text = text;\n        if (new.target === Text) Object.freeze(this);\n    }\n}\n\nObject.defineProperty(Text.prototype, kind, {value: 'text'});\n\nexport function isText(value: unknown): value is Text {\n    return kindOf(value) === 'text';\n}\n\n/** Raw SQL, inserted verbatim without any escaping (*use with care*). */\nexport function text(text: string): Text {\n    return new Text(text);\n}\n\nexport const raw: typeof text = text;\n"]}

package/Value.d.ts

@@ -1,9 +1,22 @@
-import { Expression } from "./Expression";
-import { Template } from "./Template";
+import { Expression, kind } from "./Expression.js";
+import { Template } from "./Template.js";
+export interface Value {
+    readonly [kind]: 'value';
+}
+/** A value that adapters pass as a bound parameter. The wrapper is frozen; the wrapped value is not copied. */
 export declare class Value extends Expression {
-    readonly value: any;
-    constructor(value: any);
+    readonly value: unknown;
+    constructor(value: unknown);
 }
-export declare function value(value: any): Expression;
-export declare function values(values: any[], separator?: string): Template;
+export declare function isValue(value: unknown): value is Value;
+/**
+ * Wraps `value` as a bound Value. Expressions are passed through unchanged and `undefined` becomes `null`.
+ * Throws for an instance of a user subclass of Expression (subclassing Expression is not supported).
+ */
+export declare function value(value: unknown): Expression;
+/**
+ * Multiple values separated by `separator` (default `text(', ')`).
+ * The separator is an Expression so any raw SQL is explicit at the call site.
+ */
+export declare function values(values: readonly unknown[], separator?: Expression): Template;
 export declare const spread: typeof values;

package/Value.js

@@ -1,27 +1,41 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.spread = exports.values = exports.value = exports.Value = void 0;
-const Expression_1 = require("./Expression");
-const Template_1 = require("./Template");
-const Text_1 = require("./Text");
-class Value extends Expression_1.Expression {
+import { Expression, isExpression, kind, kindOf } from "./Expression.js";
+import { template, Template } from "./Template.js";
+import { text } from "./Text.js";
+import { invalidExpression } from "./invalid.js";
+import { separated } from "./separated.js";
+/** A value that adapters pass as a bound parameter. The wrapper is frozen; the wrapped value is not copied. */
+export class Value extends Expression {
+    value;
     constructor(value) {
         super();
         this.value = value;
+        if (new.target === Value)
+            Object.freeze(this);
     }
 }
-exports.Value = Value;
-function value(value) {
-    if (value instanceof Expression_1.Expression)
+Object.defineProperty(Value.prototype, kind, { value: 'value' });
+export function isValue(value) {
+    return kindOf(value) === 'value';
+}
+/**
+ * Wraps `value` as a bound Value. Expressions are passed through unchanged and `undefined` becomes `null`.
+ * Throws for an instance of a user subclass of Expression (subclassing Expression is not supported).
+ */
+export function value(value) {
+    if (isExpression(value))
         return value;
+    if (value instanceof Expression)
+        throw invalidExpression(value, 'SQL');
     if (value === undefined)
         return new Value(null);
     return new Value(value);
 }
-exports.value = value;
-function values(values, separator = ', ') {
-    return (0, Template_1.template)(...values.flatMap((v, i) => i > 0 ? [(0, Text_1.text)(separator), value(v)] : [value(v)]));
+/**
+ * Multiple values separated by `separator` (default `text(', ')`).
+ * The separator is an Expression so any raw SQL is explicit at the call site.
+ */
+export function values(values, separator = text(', ')) {
+    return template(...separated(values.map(value), separator));
 }
-exports.values = values;
-exports.spread = values;
+export const spread = values;
 //# sourceMappingURL=Value.js.map

package/Value.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Value.js","sourceRoot":"","sources":["../src/Value.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,EAAC,MAAM,iBAAiB,CAAC;AACvE,OAAO,EAAC,QAAQ,EAAE,QAAQ,EAAC,MAAM,eAAe,CAAC;AACjD,OAAO,EAAC,IAAI,EAAC,MAAM,WAAW,CAAC;AAC/B,OAAO,EAAC,iBAAiB,EAAC,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAC,SAAS,EAAC,MAAM,gBAAgB,CAAC;AAMzC,+GAA+G;AAC/G,MAAM,OAAO,KAAM,SAAQ,UAAU;IACxB,KAAK,CAAU;IAExB,YAAY,KAAc;QACtB,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,IAAI,MAAM,KAAK,KAAK;YAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAClD,CAAC;CACJ;AAED,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,SAAS,EAAE,IAAI,EAAE,EAAC,KAAK,EAAE,OAAO,EAAC,CAAC,CAAC;AAE/D,MAAM,UAAU,OAAO,CAAC,KAAc;IAClC,OAAO,MAAM,CAAC,KAAK,CAAC,KAAK,OAAO,CAAC;AACrC,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,KAAK,CAAC,KAAc;IAChC,IAAI,YAAY,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACtC,IAAI,KAAK,YAAY,UAAU;QAAE,MAAM,iBAAiB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACvE,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,IAAI,KAAK,CAAC,IAAI,CAAC,CAAC;IAChD,OAAO,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC;AAC5B,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,MAAM,CAAC,MAA0B,EAAE,SAAS,GAAe,IAAI,CAAC,IAAI,CAAC;IACjF,OAAO,QAAQ,CAAC,GAAG,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC;AAChE,CAAC;AAED,MAAM,CAAC,MAAM,MAAM,GAAkB,MAAM,CAAC","sourcesContent":["import {Expression, isExpression, kind, kindOf} from \"./Expression.js\";\nimport {template, Template} from \"./Template.js\";\nimport {text} from \"./Text.js\";\nimport {invalidExpression} from \"./invalid.js\";\nimport {separated} from \"./separated.js\";\n\nexport interface Value {\n    readonly [kind]: 'value';\n}\n\n/** A value that adapters pass as a bound parameter. The wrapper is frozen; the wrapped value is not copied. */\nexport class Value extends Expression {\n    readonly value: unknown;\n\n    constructor(value: unknown) {\n        super();\n        this.value = value;\n        if (new.target === Value) Object.freeze(this);\n    }\n}\n\nObject.defineProperty(Value.prototype, kind, {value: 'value'});\n\nexport function isValue(value: unknown): value is Value {\n    return kindOf(value) === 'value';\n}\n\n/**\n * Wraps `value` as a bound Value. Expressions are passed through unchanged and `undefined` becomes `null`.\n * Throws for an instance of a user subclass of Expression (subclassing Expression is not supported).\n */\nexport function value(value: unknown): Expression {\n    if (isExpression(value)) return value;\n    if (value instanceof Expression) throw invalidExpression(value, 'SQL');\n    if (value === undefined) return new Value(null);\n    return new Value(value);\n}\n\n/**\n * Multiple values separated by `separator` (default `text(', ')`).\n * The separator is an Expression so any raw SQL is explicit at the call site.\n */\nexport function values(values: readonly unknown[], separator: Expression = text(', ')): Template {\n    return template(...separated(values.map(value), separator));\n}\n\nexport const spread: typeof values = values;\n"]}

package/index.d.ts

@@ -1,6 +1,6 @@
-export * from "./Expression";
-export * from "./Identifier";
-export * from "./SQL";
-export * from "./Template";
-export * from "./Text";
-export * from "./Value";
+export * from "./Expression.js";
+export * from "./Identifier.js";
+export * from "./SQL.js";
+export * from "./Template.js";
+export * from "./Text.js";
+export * from "./Value.js";

package/index.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-(0, tslib_1.__exportStar)(require("./Expression"), exports);
-(0, tslib_1.__exportStar)(require("./Identifier"), exports);
-(0, tslib_1.__exportStar)(require("./SQL"), exports);
-(0, tslib_1.__exportStar)(require("./Template"), exports);
-(0, tslib_1.__exportStar)(require("./Text"), exports);
-(0, tslib_1.__exportStar)(require("./Value"), exports);
+export * from "./Expression.js";
+export * from "./Identifier.js";
+export * from "./SQL.js";
+export * from "./Template.js";
+export * from "./Text.js";
+export * from "./Value.js";
 //# sourceMappingURL=index.js.map

package/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAA;AAC/B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,UAAU,CAAA;AACxB,cAAc,eAAe,CAAA;AAC7B,cAAc,WAAW,CAAA;AACzB,cAAc,YAAY,CAAA","sourcesContent":["export * from \"./Expression.js\"\nexport * from \"./Identifier.js\"\nexport * from \"./SQL.js\"\nexport * from \"./Template.js\"\nexport * from \"./Text.js\"\nexport * from \"./Value.js\"\n\n\n"]}

package/invalid.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The error for something that is not a usable expression where one is required.
+ * An instance of a user subclass of Expression has no `kind` brand, so no adapter could render it:
+ * it is rejected rather than being bound as a value or silently dropped.
+ */
+export declare function invalidExpression(value: unknown, where: string): TypeError;

package/invalid.js

@@ -0,0 +1,14 @@
+import { Expression } from "./Expression.js";
+/**
+ * The error for something that is not a usable expression where one is required.
+ * An instance of a user subclass of Expression has no `kind` brand, so no adapter could render it:
+ * it is rejected rather than being bound as a value or silently dropped.
+ */
+export function invalidExpression(value, where) {
+    if (value instanceof Expression) {
+        return new TypeError(`${where}: ${value.constructor.name} extends Expression but is not a supported kind of expression. ` +
+            `Subclassing Expression is not supported: build expressions with SQL, text, id, value or template instead`);
+    }
+    return new TypeError(`${where} can only contain Expressions but got ${value === null ? 'null' : typeof value}`);
+}
+//# sourceMappingURL=invalid.js.map

package/invalid.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"invalid.js","sourceRoot":"","sources":["../src/invalid.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,iBAAiB,CAAC;AAE3C;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAAc,EAAE,KAAa;IAC3D,IAAI,KAAK,YAAY,UAAU,EAAE,CAAC;QAC9B,OAAO,IAAI,SAAS,CAAC,GAAG,KAAK,KAAK,KAAK,CAAC,WAAW,CAAC,IAAI,iEAAiE;YACrH,0GAA0G,CAAC,CAAC;IACpH,CAAC;IACD,OAAO,IAAI,SAAS,CAAC,GAAG,KAAK,yCAAyC,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,KAAK,EAAE,CAAC,CAAC;AACpH,CAAC","sourcesContent":["import {Expression} from \"./Expression.js\";\n\n/**\n * The error for something that is not a usable expression where one is required.\n * An instance of a user subclass of Expression has no `kind` brand, so no adapter could render it:\n * it is rejected rather than being bound as a value or silently dropped.\n */\nexport function invalidExpression(value: unknown, where: string): TypeError {\n    if (value instanceof Expression) {\n        return new TypeError(`${where}: ${value.constructor.name} extends Expression but is not a supported kind of expression. ` +\n            `Subclassing Expression is not supported: build expressions with SQL, text, id, value or template instead`);\n    }\n    return new TypeError(`${where} can only contain Expressions but got ${value === null ? 'null' : typeof value}`);\n}\n"]}

package/package.json

@@ -1,9 +1,11 @@
 {
   "name": "@triptease/sql-template",
-  "version": "0.23.24",
+  "version": "0.35.6",
+  "type": "module",
   "repository": {
     "type": "git",
-    "url": "git+ssh://git@github.com/triptease/sql-template.git"
+    "url": "git+https://github.com/triptease/sql-template.git",
+    "directory": "sql-template/src"
   },
   "author": "Triptease",
   "license": "MIT",
@@ -11,17 +13,19 @@
     "url": "https://github.com/triptease/sql-template/issues"
   },
   "homepage": "https://github.com/triptease/sql-template/",
-  "publishConfig": {
-    "directory": "../dist",
-    "access": "public"
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./package.json": "./package.json"
   },
   "files": [
-    "*.js",
-    "*.d.ts"
-  ],
-  "dependencies": {
-    "tslib": "^2.3.1"
-  },
-  "scripts": {},
-  "readme": "# Sql Template\r\n\r\nThis is yet another SQL tagged template for Typescript/Javascript\r\n\r\n## Why another library?\r\n\r\n* Typescript first\r\n* Functional/Immutable\r\n* Super simple implementation (the main SQL function is [3 lines of code](https://github.com/triptease/sql-template/blob/master/sql-template/src/SQL.ts#L5))\r\n* Full escaping of identifiers and values\r\n* Plugable to any DB (currently only Postgres @triptease\\sql-template-postgres )\r\n* Automatic support for prepareStatement naming (Postgres)\r\n\r\n## Installation\r\n\r\n```shell\r\nnpm install @triptease/sql-template @triptease/sql-template-postgres\r\n```\r\n\r\n## Usage\r\n\r\n```javascript\r\nimport {SQL, id} from \"@triptease/sql-template\";\r\nimport {statement} from \"@triptease/sql-template-postgres\";\r\n\r\nclient.query(statement(SQL`select * from ${id(table)} where name = ${name}`));\r\n```\r\n\r\n## Cheatsheet\r\n\r\n### Core (@triptease/sql-template) \r\n\r\n| function                                       | Description                                                          |\r\n|------------------------------------------------|----------------------------------------------------------------------|\r\n| `SQL`                                          | The main function to create tagged templates for SQL (*DB agnostic*) |\r\n| `text` (alias `raw`)                           | Input raw SQL without any escaping (*use with care*)                 |\r\n | `id` / `ids`                                   | Input dynamic identifiers into SQL (*escaped as needed*)             |\r\n | `value` (optional) / `values` (alias `spread`) | Input one or more values into SQL (*escaped as needed*)              |\r\n\r\n\r\n### Postgres (@triptease/sql-template-postgres)\r\n\r\n| function                                       | Description                                                         |\r\n|------------------------------------------------|---------------------------------------------------------------------|\r\n| `statement`                                    | Converts DB agnostic `SQL` template into postgres statement         |\r\n| `prepareStatement`                             | Converts DB agnostic `SQL` template into postgres prepare statement |\r\n| `debugQuery`                                   | Used to debug a query (*use with care*)                             |\r\n\r\n*use with care -> Used incorrectly you can open yourself up to SQL injection*\r\n\r\n\r\n### Extending\r\n\r\nIt is incredibly simple to extend to other DBs, have a look at the [postgres implementation](https://github.com/triptease/sql-template/blob/master/sql-template-postgres/src/index.ts#L17). \r\n\r\n\r\n"
-}
+    "**/*.js",
+    "**/*.js.map",
+    "**/*.d.ts",
+    "README.md"
+  ]
+}

package/separated.d.ts

@@ -0,0 +1,3 @@
+import { type Expression } from "./Expression.js";
+/** @internal Interleaves `separator` between `expressions`. */
+export declare function separated(expressions: readonly Expression[], separator: Expression): Expression[];

package/separated.js

@@ -0,0 +1,9 @@
+import { isExpression } from "./Expression.js";
+/** @internal Interleaves `separator` between `expressions`. */
+export function separated(expressions, separator) {
+    if (!isExpression(separator)) {
+        throw new TypeError('separator must be an Expression, e.g. text(\', \') (raw strings are no longer accepted)');
+    }
+    return expressions.flatMap((e, i) => i > 0 ? [separator, e] : [e]);
+}
+//# sourceMappingURL=separated.js.map

package/separated.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"separated.js","sourceRoot":"","sources":["../src/separated.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,YAAY,EAAC,MAAM,iBAAiB,CAAC;AAE9D,+DAA+D;AAC/D,MAAM,UAAU,SAAS,CAAC,WAAkC,EAAE,SAAqB;IAC/E,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,EAAE,CAAC;QAC3B,MAAM,IAAI,SAAS,CAAC,yFAAyF,CAAC,CAAC;IACnH,CAAC;IACD,OAAO,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACvE,CAAC","sourcesContent":["import {type Expression, isExpression} from \"./Expression.js\";\n\n/** @internal Interleaves `separator` between `expressions`. */\nexport function separated(expressions: readonly Expression[], separator: Expression): Expression[] {\n    if (!isExpression(separator)) {\n        throw new TypeError('separator must be an Expression, e.g. text(\\', \\') (raw strings are no longer accepted)');\n    }\n    return expressions.flatMap((e, i) => i > 0 ? [separator, e] : [e]);\n}\n"]}