@intentius/chant-lexicon-sql 0.0.0-stage → 0.112.1

package/dist/lint/rules/postgres-templates.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Finding the Postgres tags in a source file, for the source-level rules. A
+ * tag is Postgres's because of the module it is imported from: the
+ * `/postgres` subpath, or the package root for the tags whose names
+ * ClickHouse does not export (the root's `table` and `view` are
+ * ClickHouse's).
+ */
+import type * as ts from "typescript";
+import { type Token } from "../../postgres/tokens.js";
+import type { PostgresTag } from "../../postgres/entities.js";
+import { type FoundTemplate, type TemplateSource } from "../../core/find-templates.js";
+export { templatePosition, tokenPosition } from "../../core/find-templates.js";
+export declare const POSTGRES_TEMPLATE_SOURCES: readonly TemplateSource<PostgresTag>[];
+export type PostgresFoundTemplate = FoundTemplate<PostgresTag>;
+/** Every Postgres template in the file. */
+export declare function findPostgresTemplates(source: ts.SourceFile): PostgresFoundTemplate[];
+export declare const postgresTokensOf: (found: PostgresFoundTemplate) => Token[];
+//# sourceMappingURL=postgres-templates.d.ts.map

package/dist/lint/rules/postgres-templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-templates.d.ts","sourceRoot":"","sources":["../../../src/lint/rules/postgres-templates.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAY,KAAK,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAoB,KAAK,aAAa,EAAE,KAAK,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAEtG,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAE5E,eAAO,MAAM,yBAAyB,EAAE,SAAS,cAAc,CAAC,WAAW,CAAC,EAW3E,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,aAAa,CAAC,WAAW,CAAC,CAAC;AAE/D,2CAA2C;AAC3C,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,GAAG,qBAAqB,EAAE,CAEpF;AAED,eAAO,MAAM,gBAAgB,GAAI,OAAO,qBAAqB,KAAG,KAAK,EAA2B,CAAC"}

package/dist/lint/rules/sqlch001.d.ts

@@ -0,0 +1,12 @@
+import type { LintRule } from "@intentius/chant/lint/rule";
+/**
+ * SQLCH001: the DDL in a `database`, `table` or `view` template does not parse, or holds another statement than its tag.
+ *
+ * The same parse runs when the build calls the tag, and fails the build there.
+ * This rule reports it in the editor and in `chant lint`, at the token, before
+ * anything is built. Interpolations are references here, since lint cannot
+ * know their values, so an error inside text a string interpolation supplies
+ * is left to the build.
+ */
+export declare const sqlch001: LintRule;
+//# sourceMappingURL=sqlch001.d.ts.map

package/dist/lint/rules/sqlch001.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlch001.d.ts","sourceRoot":"","sources":["../../../src/lint/rules/sqlch001.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA+B,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAOxF;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ,EAAE,QAoCtB,CAAC"}

package/dist/lint/rules/sqlch002.d.ts

@@ -0,0 +1,11 @@
+import type { LintRule } from "@intentius/chant/lint/rule";
+/**
+ * SQLCH002: a `Nullable` column in a table's sort key or primary key.
+ *
+ * ClickHouse refuses to create the table ("Sorting key contains nullable
+ * columns") unless the table sets `allow_nullable_key = 1`, and with it a
+ * `NULL` sorts as a value of its own. The rule reads the types written in the
+ * column list; a key over a column of an inferred type is left to the server.
+ */
+export declare const sqlch002: LintRule;
+//# sourceMappingURL=sqlch002.d.ts.map

package/dist/lint/rules/sqlch002.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlch002.d.ts","sourceRoot":"","sources":["../../../src/lint/rules/sqlch002.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA+B,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAkDxF;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,EAAE,QAwDtB,CAAC"}

package/dist/lint/rules/sqlch003.d.ts

@@ -0,0 +1,12 @@
+import type { LintRule } from "@intentius/chant/lint/rule";
+/**
+ * SQLCH003: a column written as `${events.kind}` instead of `${events.columns.kind}`.
+ *
+ * Columns are reached through `.columns`. `kind`, `lexicon`, `entityType`,
+ * `props`, `sqlName` and `dependsOn` are the entity's own fields, so
+ * `${events.kind}` is the string `"resource"`, which the tag splices in as SQL
+ * text: the statement builds and means something else. This rule flags it for
+ * an entity the file declares or imports from another project file.
+ */
+export declare const sqlch003: LintRule;
+//# sourceMappingURL=sqlch003.d.ts.map

package/dist/lint/rules/sqlch003.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlch003.d.ts","sourceRoot":"","sources":["../../../src/lint/rules/sqlch003.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAA+B,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AA0BxF;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ,EAAE,QA+BtB,CAAC"}

package/dist/lint/rules/sqlpg001.d.ts

@@ -0,0 +1,16 @@
+import type { LintRule } from "@intentius/chant/lint/rule";
+/**
+ * SQLPG001: the DDL in a Postgres template does not parse, or does not hold
+ * what its tag declares.
+ *
+ * The same parse runs when the build calls the tag, and fails the build there.
+ * This rule reports it in the editor and in `chant lint`, at the token, as a
+ * line and column of the `.ts` file, before anything is built. It also reports
+ * what the tag refuses after parsing: another statement than the tag's, a
+ * second CREATE in one template, and an index with no name (its name is its
+ * identity on the server). Interpolations are references here, since lint
+ * cannot know their values, so an error inside text a string interpolation
+ * supplies is left to the build.
+ */
+export declare const sqlpg001: LintRule;
+//# sourceMappingURL=sqlpg001.d.ts.map

package/dist/lint/rules/sqlpg001.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlpg001.d.ts","sourceRoot":"","sources":["../../../src/lint/rules/sqlpg001.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA+B,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAmBxF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,QAAQ,EAAE,QAuDtB,CAAC"}

package/dist/lint/rules/sqlpg002.d.ts

@@ -0,0 +1,12 @@
+import type { LintRule } from "@intentius/chant/lint/rule";
+/**
+ * SQLPG002: a column written as `${events.kind}` instead of `${events.columns.kind}`.
+ *
+ * Columns are reached through `.columns`. `kind`, `lexicon`, `entityType`,
+ * `props`, `sqlName` and `dependsOn` are the entity's own fields, so
+ * `${events.kind}` is the string `"resource"`, which the tag splices in as SQL
+ * text: the statement builds and means something else. This rule flags it for
+ * an entity the file declares or imports from another project file.
+ */
+export declare const sqlpg002: LintRule;
+//# sourceMappingURL=sqlpg002.d.ts.map

package/dist/lint/rules/sqlpg002.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlpg002.d.ts","sourceRoot":"","sources":["../../../src/lint/rules/sqlpg002.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAA+B,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AA0BxF;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ,EAAE,QA+BtB,CAAC"}

package/dist/lint/rules/sqlpg003.d.ts

@@ -0,0 +1,16 @@
+import type { LintRule } from "@intentius/chant/lint/rule";
+/**
+ * SQLPG003: an object named in a string where Postgres reads a `regclass`:
+ * `nextval('app.ticket_seq')`, `currval(...)`, `setval(...)`, or
+ * `'app.ticket_seq'::regclass`.
+ *
+ * A name inside a string is text to the build, so it records no reference:
+ * the table does not depend on the sequence, the creation order can put the
+ * table first, and the create fails. Interpolating the object instead,
+ * `nextval(${ticketSeq})`, renders the same `regclass` literal the catalog
+ * prints (`nextval('app.ticket_seq'::regclass)`) and keeps the edge. A
+ * sequence another tool owns is the exception, which is why this is a
+ * warning.
+ */
+export declare const sqlpg003: LintRule;
+//# sourceMappingURL=sqlpg003.d.ts.map

package/dist/lint/rules/sqlpg003.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlpg003.d.ts","sourceRoot":"","sources":["../../../src/lint/rules/sqlpg003.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA+B,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAMxF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,QAAQ,EAAE,QAuCtB,CAAC"}

package/dist/lint/rules/sqlpg004.d.ts

@@ -0,0 +1,21 @@
+import type { LintRule } from "@intentius/chant/lint/rule";
+import type { PostgresProvider } from "../../postgres/providers/index.js";
+/**
+ * The provider a lint run is for: `sql.provider`, else the one provider every
+ * profile that names one agrees on. No answer (self-hosted, or profiles that
+ * disagree) leaves the rule silent. The lint engine passes the whole project
+ * config as `projectConfig`.
+ */
+export declare function providerFromConfig(config: unknown): PostgresProvider | undefined;
+/**
+ * SQLPG004: a declared extension the configured provider does not allow.
+ *
+ * `extension\`CREATE EXTENSION pg_stat_monitor\`` builds, and fails when
+ * applied to a provider whose list lacks it. The lists are the providers'
+ * documentation snapshots (see postgres/providers/types.ts), so a provider
+ * that added an extension since reports it here until the list is refreshed;
+ * disable the rule for that line. When a provider's list is partial, a name
+ * outside it is not reported.
+ */
+export declare const sqlpg004: LintRule;
+//# sourceMappingURL=sqlpg004.d.ts.map

package/dist/lint/rules/sqlpg004.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlpg004.d.ts","sourceRoot":"","sources":["../../../src/lint/rules/sqlpg004.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA+B,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAGxF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAGjE;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,OAAO,GAAG,gBAAgB,GAAG,SAAS,CAMhF;AAID;;;;;;;;;GASG;AACH,eAAO,MAAM,QAAQ,EAAE,QAwCtB,CAAC"}

package/dist/lint/rules/templates.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Finding the ClickHouse tags in a source file, for the source-level rules
+ * (and the editor). A rule reads the template's raw parts straight from the
+ * TypeScript AST and parses them the way the tag does, with every
+ * interpolation left a reference: lint cannot know the values. The finder is
+ * the shared core's (`../../core/find-templates.ts`); a tag is ClickHouse's
+ * because of the module it is imported from.
+ */
+import type * as ts from "typescript";
+import { type Token } from "../../clickhouse/tokens.js";
+import { type FoundTemplate as SqlFoundTemplate, type TemplateSource } from "../../core/find-templates.js";
+export { templatePosition, tokenPosition } from "../../core/find-templates.js";
+export type SqlTag = "database" | "table" | "view";
+/**
+ * The ClickHouse tags, by the modules they are imported from. The package
+ * root still exports them, so it counts as ClickHouse too.
+ */
+export declare const CLICKHOUSE_TEMPLATE_SOURCE: TemplateSource<SqlTag>;
+export type FoundTemplate = SqlFoundTemplate<SqlTag>;
+/** Every ClickHouse template in the file (the shared core's finder). */
+export declare function findTemplates(source: ts.SourceFile): FoundTemplate[];
+export declare const tokensOf: (found: FoundTemplate) => Token[];
+//# sourceMappingURL=templates.d.ts.map

package/dist/lint/rules/templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"templates.d.ts","sourceRoot":"","sources":["../../../src/lint/rules/templates.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAY,KAAK,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAC/D,OAAO,EAAoB,KAAK,aAAa,IAAI,gBAAgB,EAAE,KAAK,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAE1H,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAE5E,MAAM,MAAM,MAAM,GAAG,UAAU,GAAG,OAAO,GAAG,MAAM,CAAC;AAEnD;;;GAGG;AACH,eAAO,MAAM,0BAA0B,EAAE,cAAc,CAAC,MAAM,CAI7D,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC;AAErD,wEAAwE;AACxE,wBAAgB,aAAa,CAAC,MAAM,EAAE,EAAE,CAAC,UAAU,GAAG,aAAa,EAAE,CAEpE;AAED,eAAO,MAAM,QAAQ,GAAI,OAAO,aAAa,KAAG,KAAK,EAA2B,CAAC"}

package/dist/live-dialect.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Which dialect a live read is for. A build holds one dialect, so a read of
+ * declared entities follows their types; a read with nothing declared (import)
+ * follows the binding: the environment's profile URL (`postgres://` is
+ * Postgres), else `sql.dialect`, else whichever of `POSTGRES_URL` and
+ * `CLICKHOUSE_URL` is set, else ClickHouse, the first dialect.
+ */
+import type { ChantConfig } from "@intentius/chant/config";
+import type { SqlDialect } from "./dialects.js";
+export declare function dialectOfEntities(entities: ReadonlyMap<string, {
+    entityType: string;
+}> | undefined): SqlDialect;
+export declare function dialectOfBinding(input: {
+    environment?: string;
+    config?: Pick<ChantConfig, "sql">;
+    env?: Record<string, string | undefined>;
+}): SqlDialect;
+/** The binding's dialect, loading the project config from `cwd` when none is passed. */
+export declare function resolveBindingDialect(options: {
+    environment?: string;
+    config?: Pick<ChantConfig, "sql">;
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+}): Promise<SqlDialect>;
+//# sourceMappingURL=live-dialect.d.ts.map

package/dist/live-dialect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live-dialect.d.ts","sourceRoot":"","sources":["../src/live-dialect.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAG7C,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,SAAS,GAAG,UAAU,CAG/G;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE;IACtC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;IAClC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;CAC1C,GAAG,UAAU,CASb;AAED,wFAAwF;AACxF,wBAAsB,qBAAqB,CAAC,OAAO,EAAE;IAAE,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAA;CAAE,GAAG,OAAO,CAAC,UAAU,CAAC,CAG7L"}

package/dist/lsp/catalog.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The ClickHouse catalog the editor and the MCP tools read: the committed
+ * snapshot of the pinned server's `system.*` tables, parsed once and indexed
+ * by name. No server is needed; the snapshot is what generation reads too.
+ */
+import { type ClickHouseCatalog, type SettingRow } from "../spec/catalog.js";
+export interface CatalogIndex {
+    catalog: ClickHouseCatalog;
+    /** Name lookups. Names a server treats case-insensitively are also keyed lowercased. */
+    engines: Map<string, ClickHouseCatalog["tableEngines"][number]>;
+    databaseEngines: Map<string, ClickHouseCatalog["databaseEngines"][number]>;
+    types: Map<string, ClickHouseCatalog["typeFamilies"][number]>;
+    codecs: Map<string, ClickHouseCatalog["codecs"][number]>;
+    indexTypes: Map<string, ClickHouseCatalog["skipIndexTypes"][number]>;
+    mergeTreeSettings: Map<string, SettingRow>;
+    querySettings: Map<string, SettingRow>;
+    functions: Map<string, ClickHouseCatalog["functions"][number]>;
+    formats: Map<string, ClickHouseCatalog["formats"][number]>;
+}
+/** The catalog, or undefined when the snapshot cannot be read. */
+export declare function catalogIndex(): CatalogIndex | undefined;
+//# sourceMappingURL=catalog.d.ts.map

package/dist/lsp/catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../src/lsp/catalog.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,OAAO,EAAgB,KAAK,iBAAiB,EAAE,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAIxF,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,iBAAiB,CAAC;IAC3B,wFAAwF;IACxF,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;IAChE,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;IAC3E,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;IAC9D,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;IACzD,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;IACrE,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IAC3C,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACvC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;IAC/D,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;CAC5D;AAaD,kEAAkE;AAClE,wBAAgB,YAAY,IAAI,YAAY,GAAG,SAAS,CAoBvD"}

package/dist/lsp/completions.d.ts

@@ -0,0 +1,13 @@
+import type { CompletionContext, CompletionItem } from "@intentius/chant/lsp/types";
+/**
+ * Completions for the sql lexicon.
+ *
+ * Inside a `table`, `view` or `database` template they come from the catalog of
+ * the pinned ClickHouse server: engines after `ENGINE =`, type families where a
+ * column's type goes, codecs inside `CODEC(...)`, skip index types after `TYPE`,
+ * settings after `SETTINGS`, functions in expressions. Inside `${` they are the
+ * tables and views declared in the file and their columns. Anywhere else, the
+ * entity classes from the generated registry.
+ */
+export declare function completions(ctx: CompletionContext): CompletionItem[];
+//# sourceMappingURL=completions.d.ts.map

package/dist/lsp/completions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"completions.d.ts","sourceRoot":"","sources":["../../src/lsp/completions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAUpF;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,iBAAiB,GAAG,cAAc,EAAE,CAsBpE"}

package/dist/lsp/hover.d.ts

@@ -0,0 +1,12 @@
+import type { HoverContext, HoverInfo } from "@intentius/chant/lsp/types";
+/**
+ * Hover for the sql lexicon.
+ *
+ * Inside a template, a word is looked up in the catalog where the SQL before it
+ * says what kind of word it is (an engine after `ENGINE =`, a type where a type
+ * goes, a setting after `SETTINGS`), and a function when it is followed by `(`.
+ * A `${ref}` shows the table, view or column it points at, with its type.
+ * Anywhere else, the entity classes from the generated registry.
+ */
+export declare function hover(ctx: HoverContext): HoverInfo | undefined;
+//# sourceMappingURL=hover.d.ts.map

package/dist/lsp/hover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hover.d.ts","sourceRoot":"","sources":["../../src/lsp/hover.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAQ1E;;;;;;;;GAQG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,SAAS,GAAG,SAAS,CAU9D"}

package/dist/lsp/postgres-catalog.d.ts

@@ -0,0 +1,85 @@
+/**
+ * The Postgres catalogs the editor and the MCP tools read: the committed
+ * snapshots of the pinned servers (one per supported major), parsed once.
+ * No server is needed; the snapshots are what generation reads too.
+ *
+ * A name's availability is read straight off the snapshots: it is in a major
+ * when that major's snapshot lists it, so `since` and `until` here agree with
+ * the generated types' `@since` / `@until`.
+ */
+import { type PostgresCatalog } from "../spec/postgres-catalog.js";
+/** Every supported major's catalog, or undefined when a snapshot cannot be read. */
+export declare function postgresCatalogs(): Map<number, PostgresCatalog> | undefined;
+/** Where a name is available: the first major with it when that is not the oldest, the last when that is not the newest. */
+export interface Availability {
+    since?: number;
+    until?: number;
+}
+export interface Entry<Row> {
+    name: string;
+    /** The row from the newest major that has the name. */
+    row: Row;
+    majors: number[];
+    range: Availability;
+    detail?: string;
+}
+export declare const SECTIONS: readonly ["types", "accessMethods", "functions", "keywords", "settings", "extensions", "storageParameters"];
+export type Section = (typeof SECTIONS)[number];
+export interface TypeRow {
+    /** The SQL spelling. */
+    sqlName: string;
+    catalogName: string;
+    kind: string;
+    category: string;
+    aliasOf?: string;
+}
+export interface MethodRow {
+    name: string;
+    type: "index" | "table";
+    properties: string[];
+}
+export interface FunctionRow {
+    name: string;
+    kinds: string;
+    overloads: number;
+}
+export interface KeywordRow {
+    word: string;
+    code: string;
+    description: string;
+}
+export interface SettingRow {
+    name: string;
+    type: string;
+    context: string;
+    category: string;
+    unit: string | null;
+    default: string | null;
+    min: string | null;
+    max: string | null;
+}
+export interface ExtensionRow {
+    name: string;
+    defaultVersion: string;
+    description: string | null;
+}
+export interface StorageRow {
+    name: string;
+    targets: string[];
+    type?: unknown;
+}
+/** `since`/`until` for the majors a name is in. */
+export declare function rangeOf(majors: readonly number[]): Availability;
+/** "14 to 17", "16 and later" or "" when in every major. */
+export declare function describeRange(r: Availability): string;
+/** A section across every major, one entry per name. */
+export declare function section<Row>(name: Section): Map<string, Entry<Row>> | undefined;
+/** The entries of a section that exist at `major`. */
+export declare function entriesAt<Row>(name: Section, major: number): Entry<Row>[];
+/** The entry for `name` at `major`, matching case-insensitively for names Postgres folds. */
+export declare function entryAt<Row>(name: Section, key: string, major: number): Entry<Row> | undefined;
+/** `postgresMajor` in the nearest `chant.config.*` above a file, when it names a supported one. */
+export declare function configuredMajor(fileName: string): number | undefined;
+/** The major a file is written for: the project's configured one, else the newest. */
+export declare function majorFor(fileName: string): number;
+//# sourceMappingURL=postgres-catalog.d.ts.map

package/dist/lsp/postgres-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-catalog.d.ts","sourceRoot":"","sources":["../../src/lsp/postgres-catalog.ts"],"names":[],"mappings":"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"}

package/dist/lsp/postgres-template.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Finding where the cursor is inside a Postgres template, and what the SQL
+ * before it says should come next. Shares the template finder with the lint
+ * rules, so the editor and `chant lint` agree on which tags are Postgres's.
+ */
+import { type Token } from "../postgres/tokens.js";
+import type { PostgresTag } from "../postgres/entities.js";
+import { type PostgresFoundTemplate } from "../lint/rules/postgres-templates.js";
+import { type Located as CoreLocated } from "../core/find-templates.js";
+export type PostgresLocated = CoreLocated<PostgresTag>;
+/** The Postgres template the source offset `at` is inside, and where in it. */
+export declare function locatePostgres(content: string, at: number, fileName?: string): PostgresLocated | undefined;
+/** Significant tokens of the template up to `offset` in `part`; undefined when the text before it does not tokenize. */
+export declare function postgresTokensBefore(found: PostgresFoundTemplate, part: number, offset: number): Token[] | undefined;
+export type PostgresExpect = "index-method" | "table-method" | "type" | "storage-parameter" | "extension" | "function" | "keyword";
+/** What the SQL before the cursor expects; undefined where a name of the user's own goes. */
+export declare function postgresExpectAfter(sig: readonly Token[], tag: PostgresTag): PostgresExpect | undefined;
+/** The storage-parameter target a template's `WITH (...)` is for. */
+export declare function storageTarget(sig: readonly Token[], tag: PostgresTag): string;
+export interface PostgresDeclared {
+    /** The const the template is bound to. */
+    name: string;
+    tag: PostgresTag;
+    /** The kind, as a reader says it: `table`, `materialized view`, `enum type`. */
+    kind: string;
+    /** The name the DDL gives the object, interpolations written back as `${...}`. */
+    sqlName: string;
+    columns: Array<{
+        name: string;
+        type?: string;
+    }>;
+}
+/** Every `const x = table\`...\`` (and the other tags) in the content that parses, by const name. */
+export declare function postgresDeclarations(content: string, fileName?: string): PostgresDeclared[];
+//# sourceMappingURL=postgres-template.d.ts.map

package/dist/lsp/postgres-template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-template.d.ts","sourceRoot":"","sources":["../../src/lsp/postgres-template.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAsB,KAAK,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAEpE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAoD,KAAK,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AAChI,OAAO,EAAY,KAAK,OAAO,IAAI,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAE/E,MAAM,MAAM,eAAe,GAAG,WAAW,CAAC,WAAW,CAAC,CAAC;AAEvD,+EAA+E;AAC/E,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,QAAQ,SAAY,GAAG,eAAe,GAAG,SAAS,CAE7G;AAED,wHAAwH;AACxH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,qBAAqB,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,KAAK,EAAE,GAAG,SAAS,CAOpH;AAED,MAAM,MAAM,cAAc,GAAG,cAAc,GAAG,cAAc,GAAG,MAAM,GAAG,mBAAmB,GAAG,WAAW,GAAG,UAAU,GAAG,SAAS,CAAC;AASnI,6FAA6F;AAC7F,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,SAAS,KAAK,EAAE,EAAE,GAAG,EAAE,WAAW,GAAG,cAAc,GAAG,SAAS,CAoCvG;AAED,qEAAqE;AACrE,wBAAgB,aAAa,CAAC,GAAG,EAAE,SAAS,KAAK,EAAE,EAAE,GAAG,EAAE,WAAW,GAAG,MAAM,CAQ7E;AAID,MAAM,WAAW,gBAAgB;IAC/B,0CAA0C;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,WAAW,CAAC;IACjB,gFAAgF;IAChF,IAAI,EAAE,MAAM,CAAC;IACb,kFAAkF;IAClF,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACjD;AAWD,qGAAqG;AACrG,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,SAAY,GAAG,gBAAgB,EAAE,CAgD9F"}

package/dist/lsp/postgres.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Completions and hover inside Postgres templates (chant #3283). Words come
+ * from the committed catalogs of the pinned servers, limited to what the
+ * project's major has (`sql.postgresMajor`, else the newest). `${` offers the
+ * objects declared in the file and `${t.columns.` their columns with types.
+ *
+ * Both entry points return undefined when the cursor is not in a Postgres
+ * template, so the ClickHouse provider (and the generic registry one) answer.
+ */
+import type { CompletionContext, CompletionItem, HoverContext, HoverInfo } from "@intentius/chant/lsp/types";
+/** Completions when the cursor is in a Postgres template; undefined when it is not. */
+export declare function postgresCompletions(ctx: CompletionContext): CompletionItem[] | undefined;
+/** Hover when the cursor is in a Postgres template; undefined when it is not (or there is nothing to say). */
+export declare function postgresHover(ctx: HoverContext): {
+    handled: boolean;
+    info?: HoverInfo;
+};
+/** Hover text for the expression written in a `${}`, or undefined when it is not a reference this can follow. */
+export declare function resolvePostgresReference(content: string, expression: string, file: string): string | undefined;
+//# sourceMappingURL=postgres.d.ts.map

package/dist/lsp/postgres.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres.d.ts","sourceRoot":"","sources":["../../src/lsp/postgres.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAsC7G,uFAAuF;AACvF,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,iBAAiB,GAAG,cAAc,EAAE,GAAG,SAAS,CAkBxF;AAgFD,8GAA8G;AAC9G,wBAAgB,aAAa,CAAC,GAAG,EAAE,YAAY,GAAG;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,SAAS,CAAA;CAAE,CAWvF;AA+FD,iHAAiH;AACjH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAW9G"}

package/dist/lsp/refs.d.ts

@@ -0,0 +1,8 @@
+/**
+ * What a `${...}` in a template points at: a table or view declared in the same
+ * file or imported from a relative path, or one of its columns. The answer is
+ * the hover text, from the source of the declaration.
+ */
+/** Hover text for the expression written in a `${}`, or undefined when it is not a reference this can follow. */
+export declare function resolveReference(content: string, expression: string, fileName: string): string | undefined;
+//# sourceMappingURL=refs.d.ts.map

package/dist/lsp/refs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refs.d.ts","sourceRoot":"","sources":["../../src/lsp/refs.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAmCH,iHAAiH;AACjH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAY1G"}

package/dist/lsp/registry.d.ts

@@ -0,0 +1,4 @@
+import { LexiconIndex } from "@intentius/chant/lsp/lexicon-providers";
+/** The generated entity registry, indexed once. Empty when generation has not run. */
+export declare function registryIndex(): LexiconIndex;
+//# sourceMappingURL=registry.d.ts.map

package/dist/lsp/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/lsp/registry.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAqB,MAAM,wCAAwC,CAAC;AAMzF,sFAAsF;AACtF,wBAAgB,aAAa,IAAI,YAAY,CAU5C"}

package/dist/lsp/template.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Finding where the cursor is inside a `database`, `table` or `view` template,
+ * and what the SQL before it says should come next. Shares the template finder
+ * with the lint rules, so the editor and `chant lint` agree on what a template
+ * is and which module's tags count.
+ */
+import { type Token } from "../clickhouse/tokens.js";
+import { type FoundTemplate, type SqlTag } from "../lint/rules/templates.js";
+import { type Located as CoreLocated } from "../core/find-templates.js";
+export { offsetAt, wordAround } from "../core/find-templates.js";
+export type Located = CoreLocated<SqlTag>;
+/** The ClickHouse template the source offset `at` is inside, and where in it. */
+export declare function locate(content: string, at: number, fileName?: string): Located | undefined;
+/** Significant tokens of the template up to `offset` in `part`; undefined when the text before it does not tokenize. */
+export declare function tokensBefore(found: FoundTemplate, part: number, offset: number): Token[] | undefined;
+/** What the SQL before the cursor expects. */
+export type Expect = "engine" | "type" | "codec" | "index-type" | "merge-tree-setting" | "query-setting" | "function";
+export declare function expectAfter(sig: readonly Token[], tag: SqlTag): Expect | undefined;
+export interface Declared {
+    /** The const the template is bound to. */
+    name: string;
+    tag: SqlTag;
+    /** The name the DDL gives the object, interpolations written back as `${...}`. */
+    sqlName: string;
+    materialized: boolean;
+    columns: Array<{
+        name: string;
+        type?: string;
+    }>;
+    engine?: string;
+}
+/** Every `const x = table\`...\`` in the content that parses, by const name. */
+export declare function declarations(content: string, fileName?: string): Declared[];
+//# sourceMappingURL=template.d.ts.map

package/dist/lsp/template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template.d.ts","sourceRoot":"","sources":["../../src/lsp/template.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAsB,KAAK,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAEtE,OAAO,EAA6C,KAAK,aAAa,EAAE,KAAK,MAAM,EAAE,MAAM,yBAAyB,CAAC;AACrH,OAAO,EAAY,KAAK,OAAO,IAAI,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAE/E,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAE9D,MAAM,MAAM,OAAO,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC;AAE1C,iFAAiF;AACjF,wBAAgB,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,QAAQ,SAAY,GAAG,OAAO,GAAG,SAAS,CAE7F;AAED,wHAAwH;AACxH,wBAAgB,YAAY,CAAC,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,KAAK,EAAE,GAAG,SAAS,CAOpG;AAED,8CAA8C;AAC9C,MAAM,MAAM,MAAM,GACd,QAAQ,GACR,MAAM,GACN,OAAO,GACP,YAAY,GACZ,oBAAoB,GACpB,eAAe,GACf,UAAU,CAAC;AAef,wBAAgB,WAAW,CAAC,GAAG,EAAE,SAAS,KAAK,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAmDlF;AAQD,MAAM,WAAW,QAAQ;IACvB,0CAA0C;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,kFAAkF;IAClF,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,OAAO,CAAC;IACtB,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAChD,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAWD,gFAAgF;AAChF,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,SAAY,GAAG,QAAQ,EAAE,CA8B9E"}

package/dist/manifest.json

@@ -0,0 +1,8 @@
+{
+  "name": "sql",
+  "version": "0.112.1",
+  "chantVersion": ">=0.1.0",
+  "namespace": "SQL",
+  "intrinsics": [],
+  "pseudoParameters": {}
+}

package/dist/mcp/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * MCP contributions for the sql lexicon (chant #3210). Tools answer from the
+ * committed ClickHouse catalog and the tag parser, so an agent can look up an
+ * engine, a type or a setting, and check a statement, without a server.
+ *
+ * Tools register as `sql:<verb>` and resources as `chant://sql/<path>`.
+ */
+import type { McpResourceContribution, McpToolContribution } from "@intentius/chant/mcp/types";
+/** The tools the sql lexicon contributes. */
+export declare function sqlMcpTools(): McpToolContribution[];
+/** The resources the sql lexicon contributes. */
+export declare function sqlMcpResources(): McpResourceContribution[];
+//# sourceMappingURL=index.d.ts.map

package/dist/mcp/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mcp/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAwO/F,6CAA6C;AAC7C,wBAAgB,WAAW,IAAI,mBAAmB,EAAE,CAQnD;AAsBD,iDAAiD;AACjD,wBAAgB,eAAe,IAAI,uBAAuB,EAAE,CA+B3D"}

package/dist/mcp/postgres.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The Postgres side of the sql MCP tools and resources (chant #3283). Rows
+ * come from the committed catalogs of the pinned servers, one per major; a
+ * name present in only some majors carries `since` and `until`, as the
+ * generated types' `@since` / `@until` do.
+ */
+import type { McpResourceContribution } from "@intentius/chant/mcp/types";
+export declare const POSTGRES_KINDS: readonly ["type", "index-method", "table-method", "storage-parameter", "setting", "function", "keyword", "extension"];
+export type PostgresKind = (typeof POSTGRES_KINDS)[number];
+type Row = {
+    name: string;
+    summary?: string;
+    since?: number;
+    until?: number;
+};
+export declare function asPostgresKind(value: unknown): PostgresKind;
+/** The major a tool call is about: `major` when given, else every major (undefined). */
+export declare function asMajor(value: unknown): number | undefined;
+/** The rows of a kind, each with its range; only those at `major` when one is given. */
+export declare function postgresRows(kind: PostgresKind, major?: number): Row[];
+export declare function postgresLookup(params: Record<string, unknown>): unknown;
+export declare function postgresSearch(params: Record<string, unknown>): unknown;
+export declare const POSTGRES_TAGS: string[];
+/** Parse one statement with the Postgres tag; an error comes back as SQLPG001 with its line and column. */
+export declare function postgresParse(tag: string, ddl: string, position: (text: string, offset: number) => {
+    line: number;
+    column: number;
+}): unknown;
+/** The Postgres resources: every supported major's names in one list, each with `since` / `until` when not in all. */
+export declare function postgresMcpResources(): McpResourceContribution[];
+export {};
+//# sourceMappingURL=postgres.d.ts.map

package/dist/mcp/postgres.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres.d.ts","sourceRoot":"","sources":["../../src/mcp/postgres.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AAM1E,eAAO,MAAM,cAAc,uHAAwH,CAAC;AACpJ,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC;AAE3D,KAAK,GAAG,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAa9E,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY,CAG3D;AAED,wFAAwF;AACxF,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAK1D;AAED,wFAAwF;AACxF,wBAAgB,YAAY,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,GAAG,EAAE,CAYtE;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAWvE;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAWvE;AAGD,eAAO,MAAM,aAAa,UAAoB,CAAC;AAE/C,2GAA2G;AAC3G,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAc7I;AAQD,sHAAsH;AACtH,wBAAgB,oBAAoB,IAAI,uBAAuB,EAAE,CAchE"}