@polyglot-sql/sdk 0.1.11 → 0.1.13

package/dist/index.d.ts

@@ -49,6 +49,10 @@ declare type AggFunc = {
      * LIMIT inside aggregate (e.g., ARRAY_AGG(x ORDER BY y LIMIT 2))
      */
     limit?: Expression | null;
+    /**
+     * Inferred data type from type annotation
+     */
+    inferred_type?: DataType | null;
 };
 
 /**
@@ -93,6 +97,10 @@ declare type AggregateFunction = {
      * IGNORE NULLS / RESPECT NULLS
      */
     ignore_nulls?: boolean | null;
+    /**
+     * Inferred data type from type annotation
+     */
+    inferred_type?: DataType | null;
 };
 
 /**
@@ -146,6 +154,10 @@ declare type Alias = {
      * Trailing comments that appeared after the alias
      */
     trailing_comments: Array<string>;
+    /**
+     * Inferred data type from type annotation
+     */
+    inferred_type?: DataType | null;
 };
 
 /** Create an expr AS name alias expression. */
@@ -614,6 +626,51 @@ declare type Annotated = {
     trailing_comments: Array<string>;
 };
 
+/**
+ * Parse SQL and annotate the AST with inferred type information.
+ *
+ * Parses the given SQL and runs bottom-up type inference, populating the
+ * `inferred_type` field on value-producing AST nodes (columns, operators,
+ * functions, casts, etc.). Use `ast.getInferredType(expr)` to read the
+ * inferred type from any expression node.
+ *
+ * @param sql - The SQL string to parse and annotate
+ * @param dialect - The dialect to use for parsing (default: Generic)
+ * @param schema - Optional schema for column type resolution
+ *
+ * @example
+ * ```typescript
+ * import { annotateTypes, ast, Dialect } from '@polyglot-sql/sdk';
+ *
+ * const result = annotateTypes(
+ *   "SELECT a + b FROM t",
+ *   Dialect.PostgreSQL,
+ *   { tables: { t: { a: "INT", b: "DOUBLE" } } }
+ * );
+ *
+ * if (result.success) {
+ *   // Walk the AST and inspect inferred types
+ *   ast.walk(result.ast![0], (node) => {
+ *     const dt = ast.getInferredType(node);
+ *     if (dt) {
+ *       console.log(ast.getExprType(node), "=>", dt);
+ *     }
+ *   });
+ * }
+ * ```
+ */
+export declare function annotateTypes(sql: string, dialect?: Dialect, schema?: Schema): AnnotateTypesResult;
+
+/**
+ * Result of an annotateTypes operation
+ */
+export declare interface AnnotateTypesResult {
+    success: boolean;
+    /** The AST with `inferred_type` fields populated on value-producing nodes */
+    ast?: Expression[];
+    error?: string;
+}
+
 /**
  * Anonymous
  */
@@ -834,6 +891,7 @@ export declare namespace ast {
         ExpressionType,
         getExprData,
         getExprType,
+        getInferredType,
         isExpressionValue,
         makeExpr,
         Alias,
@@ -1139,6 +1197,10 @@ declare type BinaryFunc = {
      * Original function name for round-trip preservation (e.g., NVL vs IFNULL)
      */
     original_name?: string | null;
+    /**
+     * Inferred data type from type annotation
+     */
+    inferred_type?: DataType | null;
 };
 
 /**
@@ -1165,6 +1227,10 @@ declare type BinaryOp = {
      * Comments after the right operand
      */
     trailing_comments: Array<string>;
+    /**
+     * Inferred data type from type annotation
+     */
+    inferred_type?: DataType | null;
 };
 
 /**
@@ -1270,6 +1336,10 @@ declare type Case = {
      * Comments from the CASE keyword (emitted after END)
      */
     comments?: Array<string>;
+    /**
+     * Inferred data type from type annotation
+     */
+    inferred_type?: DataType | null;
 };
 
 /**
@@ -1339,6 +1409,10 @@ declare type Cast = {
      * DEFAULT value ON CONVERSION ERROR (Oracle): CAST(x AS type DEFAULT val ON CONVERSION ERROR)
      */
     default?: Expression | null;
+    /**
+     * Inferred data type from type annotation
+     */
+    inferred_type?: DataType | null;
 };
 
 /** Create a CAST(expr AS type) expression. */
@@ -1535,6 +1609,10 @@ declare type Column = {
      * Source position span
      */
     span?: Span | null;
+    /**
+     * Inferred data type from type annotation
+     */
+    inferred_type?: DataType | null;
 };
 
 /**
@@ -2132,6 +2210,10 @@ declare type CountFunc = {
      * Original function name for case preservation (e.g., "count" or "COUNT")
      */
     original_name?: string | null;
+    /**
+     * Inferred data type from type annotation
+     */
+    inferred_type?: DataType | null;
 };
 
 /**
@@ -3145,6 +3227,7 @@ declare const _default: {
     tokenize: typeof tokenize;
     generate: typeof generate;
     format: typeof format;
+    annotateTypes: typeof annotateTypes;
     getDialects: typeof getDialects;
     getVersion: typeof getVersion;
     lineage: typeof lineage;
@@ -3334,12 +3417,6 @@ declare type Detach = {
     exists: boolean;
 };
 
-/**
- * Polyglot SQL Dialect Translator
- *
- * A WebAssembly-powered SQL dialect translator that can convert SQL
- * between different database dialects (PostgreSQL, MySQL, BigQuery, etc.)
- */
 /**
  * Supported SQL dialects
  */
@@ -6223,6 +6300,10 @@ declare type Function_2 = {
      * Source position span
      */
     span?: Span | null;
+    /**
+     * Inferred data type from type annotation
+     */
+    inferred_type?: DataType | null;
 };
 
 /**
@@ -6545,6 +6626,27 @@ declare function getFunctions(node: Expression): Expression[];
  */
 declare function getIdentifiers(node: Expression): Expression[];
 
+/**
+ * Get the inferred data type from an Expression, if it has been type-annotated.
+ *
+ * After calling `annotateTypes()`, value-producing expressions (columns, operators,
+ * functions, casts, etc.) carry an `inferred_type` field with their resolved SQL type.
+ *
+ * @example
+ * ```typescript
+ * const result = annotateTypes("SELECT 1 + 2", Dialect.Generic);
+ * if (result.success) {
+ *   const addExpr = result.ast![0]; // the SELECT
+ *   // Navigate to the "1 + 2" expression and check its type:
+ *   const dt = getInferredType(someExpr);
+ *   // dt => { data_type: "int", length: null, integer_spelling: false }
+ * }
+ * ```
+ *
+ * @returns The inferred DataType, or `undefined` if not annotated or not a value-producing expression.
+ */
+export declare function getInferredType(expr: Expression): DataType | undefined;
+
 /**
  * Get all literals in the AST (via WASM)
  */
@@ -6723,6 +6825,10 @@ declare type GroupConcatFunc = {
     order_by: Array<Ordered> | null;
     distinct: boolean;
     filter: Expression | null;
+    /**
+     * Inferred data type from type annotation
+     */
+    inferred_type?: DataType | null;
 };
 
 /**
@@ -6902,6 +7008,10 @@ declare type IfFunc = {
      * Original function name (IF, IFF, IIF) for round-trip preservation
      */
     original_name?: string | null;
+    /**
+     * Inferred data type from type annotation
+     */
+    inferred_type?: DataType | null;
 };
 
 export declare function ifNull(expr: ExprInput, fallback: ExprInput): Expr;
@@ -8535,6 +8645,10 @@ declare type LikeOp = {
      * Quantifier: ANY, ALL, or SOME
      */
     quantifier: string | null;
+    /**
+     * Inferred data type from type annotation
+     */
+    inferred_type?: DataType | null;
 };
 
 /**
@@ -8614,11 +8728,30 @@ export declare interface LineageResult {
 /**
  * Trace the lineage of a column through a SQL query using schema metadata.
  *
+ * When a schema is provided, columns are fully qualified and type-annotated.
+ * Each `LineageNode.expression` will have its `inferred_type` field populated
+ * with the resolved SQL data type. Use `ast.getInferredType(node.expression)`
+ * to read it.
+ *
  * @param column - Column name to trace
  * @param sql - SQL string to analyze
  * @param schema - ValidationSchema-compatible schema object
  * @param dialect - Dialect for parsing/qualification (default: 'generic')
  * @param trimSelects - Trim SELECT to only target column (default: false)
+ *
+ * @example
+ * ```typescript
+ * import { lineageWithSchema, ast } from '@polyglot-sql/sdk';
+ *
+ * const result = lineageWithSchema("name", "SELECT name FROM users", {
+ *   tables: { users: { name: "TEXT", id: "INT" } }
+ * });
+ *
+ * if (result.success) {
+ *   const dt = ast.getInferredType(result.lineage!.expression);
+ *   // dt => { data_type: "text" }
+ * }
+ * ```
  */
 export declare function lineageWithSchema(column: string, sql: string, schema: Schema, dialect?: string, trimSelects?: boolean): LineageResult;
 
@@ -8639,6 +8772,10 @@ declare type ListAggFunc = {
     order_by: Array<Ordered> | null;
     distinct: boolean;
     filter: Expression | null;
+    /**
+     * Inferred data type from type annotation
+     */
+    inferred_type?: DataType | null;
 };
 
 /**
@@ -9365,6 +9502,10 @@ declare type Nvl2Func = {
     this: Expression;
     true_value: Expression;
     false_value: Expression;
+    /**
+     * Inferred data type from type annotation
+     */
+    inferred_type?: DataType | null;
 };
 
 /**
@@ -10138,6 +10279,10 @@ export declare class Polyglot {
      * Get library version.
      */
     getVersion(): string;
+    /**
+     * Parse SQL and annotate the AST with inferred type information.
+     */
+    annotateTypes(sql: string, dialect?: Dialect, schema?: Schema): AnnotateTypesResult;
 }
 
 /**
@@ -12005,6 +12150,10 @@ declare type StringAggFunc = {
      * BigQuery LIMIT inside STRING_AGG
      */
     limit?: Expression | null;
+    /**
+     * Inferred data type from type annotation
+     */
+    inferred_type?: DataType | null;
 };
 
 /**
@@ -12176,6 +12325,10 @@ declare type Subquery = {
      * Trailing comments after the closing paren
      */
     trailing_comments: Array<string>;
+    /**
+     * Inferred data type from type annotation
+     */
+    inferred_type?: DataType | null;
 };
 
 /**
@@ -12231,6 +12384,10 @@ declare type SumIfFunc = {
     this: Expression;
     condition: Expression;
     filter: Expression | null;
+    /**
+     * Inferred data type from type annotation
+     */
+    inferred_type?: DataType | null;
 };
 
 /**
@@ -13312,6 +13469,10 @@ declare type UnaryFunc = {
      * Original function name for round-trip preservation (e.g., CHAR_LENGTH vs LENGTH)
      */
     original_name?: string | null;
+    /**
+     * Inferred data type from type annotation
+     */
+    inferred_type?: DataType | null;
 };
 
 /**
@@ -13324,6 +13485,10 @@ declare type UnaryOp = {
      * The operand expression.
      */
     this: Expression;
+    /**
+     * Inferred data type from type annotation
+     */
+    inferred_type?: DataType | null;
 };
 
 /**
@@ -13848,6 +14013,10 @@ declare type VarArgFunc = {
      * Original function name for round-trip preservation (e.g., COALESCE vs IFNULL)
      */
     original_name?: string | null;
+    /**
+     * Inferred data type from type annotation
+     */
+    inferred_type?: DataType | null;
 };
 
 /**
@@ -14624,6 +14793,10 @@ declare type WindowFunction = {
      * Oracle KEEP clause: KEEP (DENSE_RANK FIRST|LAST ORDER BY ...)
      */
     keep?: Keep | null;
+    /**
+     * Inferred data type from type annotation
+     */
+    inferred_type?: DataType | null;
 };
 
 /**

package/dist/index.js

@@ -1587,6 +1587,66 @@ class WasmWindowDefBuilder {
 }
 if (Symbol.dispose) WasmWindowDefBuilder.prototype[Symbol.dispose] = WasmWindowDefBuilder.prototype.free;
 
+/**
+ * Annotate types on a parsed SQL AST in-place.
+ *
+ * Parses the given SQL, runs type annotation (and optionally uses a schema
+ * for column type resolution), and returns the AST with `inferred_type`
+ * fields populated on value-producing nodes.
+ *
+ * # Arguments
+ * * `sql` - SQL string to parse
+ * * `dialect` - Dialect for parsing
+ * * `schema_json` - Optional JSON schema (same format as `lineage_sql_with_schema`)
+ *
+ * # Returns
+ * JSON string containing `ParseValueResult` with annotated AST
+ * @param {string} sql
+ * @param {string} dialect
+ * @param {string} schema_json
+ * @returns {string}
+ */
+function annotate_types$1(sql, dialect, schema_json) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const retptr = wasm$3.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(sql, wasm$3.__wbindgen_export, wasm$3.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(dialect, wasm$3.__wbindgen_export, wasm$3.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(schema_json, wasm$3.__wbindgen_export, wasm$3.__wbindgen_export2);
+        const len2 = WASM_VECTOR_LEN;
+        wasm$3.annotate_types(retptr, ptr0, len0, ptr1, len1, ptr2, len2);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        deferred4_0 = r0;
+        deferred4_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm$3.__wbindgen_add_to_stack_pointer(16);
+        wasm$3.__wbindgen_export4(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * Annotate types on a parsed SQL AST, returning a JsValue.
+ * @param {string} sql
+ * @param {string} dialect
+ * @param {string} schema_json
+ * @returns {any}
+ */
+function annotate_types_value$1(sql, dialect, schema_json) {
+    const ptr0 = passStringToWasm0(sql, wasm$3.__wbindgen_export, wasm$3.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(dialect, wasm$3.__wbindgen_export, wasm$3.__wbindgen_export2);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(schema_json, wasm$3.__wbindgen_export, wasm$3.__wbindgen_export2);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm$3.annotate_types_value(ptr0, len0, ptr1, len1, ptr2, len2);
+    return takeObject(ret);
+}
+
 /**
  * Add a WHERE condition to a SELECT AST.
  * @param {string} ast_json
@@ -3423,6 +3483,8 @@ const __wbg_wasmselectbuilder_free = __vite__wasmModule.__wbg_wasmselectbuilder_
 const __wbg_wasmsetopbuilder_free = __vite__wasmModule.__wbg_wasmsetopbuilder_free;
 const __wbg_wasmupdatebuilder_free = __vite__wasmModule.__wbg_wasmupdatebuilder_free;
 const __wbg_wasmwindowdefbuilder_free = __vite__wasmModule.__wbg_wasmwindowdefbuilder_free;
+const annotate_types = __vite__wasmModule.annotate_types;
+const annotate_types_value = __vite__wasmModule.annotate_types_value;
 const ast_add_where = __vite__wasmModule.ast_add_where;
 const ast_get_aggregate_functions = __vite__wasmModule.ast_get_aggregate_functions;
 const ast_get_column_names = __vite__wasmModule.ast_get_column_names;
@@ -3610,6 +3672,8 @@ const wasm$2 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
     __wbindgen_export2,
     __wbindgen_export3,
     __wbindgen_export4,
+    annotate_types,
+    annotate_types_value,
     ast_add_where,
     ast_get_aggregate_functions,
     ast_get_column_names,
@@ -3793,6 +3857,8 @@ const wasmModule = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty
     WasmSetOpBuilder,
     WasmUpdateBuilder,
     WasmWindowDefBuilder,
+    annotate_types: annotate_types$1,
+    annotate_types_value: annotate_types_value$1,
     ast_add_where: ast_add_where$1,
     ast_get_aggregate_functions: ast_get_aggregate_functions$1,
     ast_get_column_names: ast_get_column_names$1,
@@ -3869,6 +3935,16 @@ function isExpressionValue(value) {
 function makeExpr(type, data) {
   return { [type]: data };
 }
+function getInferredType(expr) {
+  const data = getExprData(expr);
+  if (data && typeof data === "object" && "inferred_type" in data) {
+    const it = data["inferred_type"];
+    if (it != null) {
+      return it;
+    }
+  }
+  return void 0;
+}
 
 function isType(type) {
   return (expr) => type in expr;
@@ -4451,6 +4527,7 @@ const index$1 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
     getExprType,
     getFunctions,
     getIdentifiers,
+    getInferredType,
     getLiterals,
     getNodeDepth,
     getParent,
@@ -5634,6 +5711,30 @@ function getDialects() {
 function getVersion() {
   return wasm.version();
 }
+function annotateTypes(sql, dialect = "generic" /* Generic */, schema) {
+  try {
+    const schemaJson = schema ? JSON.stringify(schema) : "";
+    if (typeof wasm.annotate_types_value === "function") {
+      return decodeWasmPayload(
+        wasm.annotate_types_value(sql, dialect, schemaJson)
+      );
+    }
+    if (typeof wasm.annotate_types === "function") {
+      return JSON.parse(
+        wasm.annotate_types(sql, dialect, schemaJson)
+      );
+    }
+    return {
+      success: false,
+      error: "annotate_types not available in this WASM build"
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `WASM annotate_types failed: ${errorMessage(error)}`
+    };
+  }
+}
 class Polyglot {
   static instance = null;
   constructor() {
@@ -5701,6 +5802,12 @@ class Polyglot {
   getVersion() {
     return getVersion();
   }
+  /**
+   * Parse SQL and annotate the AST with inferred type information.
+   */
+  annotateTypes(sql, dialect = "generic" /* Generic */, schema) {
+    return annotateTypes(sql, dialect, schema);
+  }
 }
 const index = {
   init,
@@ -5710,6 +5817,7 @@ const index = {
   tokenize,
   generate,
   format,
+  annotateTypes,
   getDialects,
   getVersion,
   lineage: lineage,
@@ -5723,4 +5831,4 @@ const index = {
   Polyglot
 };
 
-export { CaseBuilder, DeleteBuilder, Dialect, Expr, InsertBuilder, MergeBuilder, Polyglot, SelectBuilder, SetOpBuilder, UpdateBuilder, ValidationSeverity, WindowDefBuilder, abs, alias, and, index$1 as ast, avg, boolean, caseOf, caseWhen, cast, ceil, changesOnly, coalesce, col, concatWs, condition, count, countDistinct, currentDate, currentTime, currentTimestamp, index as default, del, deleteFrom, denseRank, diff, except, exp, extract, findAll, floor, format, formatWithOptions, func, generate, getColumns, getDialects, getSourceTables, getVersion, greatest, hasChanges, ifNull, init, initcap, insert, insertInto, intersect, isColumn, isFunction, isInitialized, isLiteral, isSelect, least, length, lineage, lineageWithSchema, lit, ln, lower, ltrim, max, mergeInto, min, not, nullIf, or, parse, plan, power, rank, renameColumns, replace, reverse, round, rowNumber, rtrim, select, sign, sqlExpr, sqlNull, sqrt, star, subquery, substring, sum, table, tokenize, transform, transpile, trim, union, unionAll, update, upper, validate, validateWithSchema, walk };
+export { CaseBuilder, DeleteBuilder, Dialect, Expr, InsertBuilder, MergeBuilder, Polyglot, SelectBuilder, SetOpBuilder, UpdateBuilder, ValidationSeverity, WindowDefBuilder, abs, alias, and, annotateTypes, index$1 as ast, avg, boolean, caseOf, caseWhen, cast, ceil, changesOnly, coalesce, col, concatWs, condition, count, countDistinct, currentDate, currentTime, currentTimestamp, index as default, del, deleteFrom, denseRank, diff, except, exp, extract, findAll, floor, format, formatWithOptions, func, generate, getColumns, getDialects, getInferredType, getSourceTables, getVersion, greatest, hasChanges, ifNull, init, initcap, insert, insertInto, intersect, isColumn, isFunction, isInitialized, isLiteral, isSelect, least, length, lineage, lineageWithSchema, lit, ln, lower, ltrim, max, mergeInto, min, not, nullIf, or, parse, plan, power, rank, renameColumns, replace, reverse, round, rowNumber, rtrim, select, sign, sqlExpr, sqlNull, sqrt, star, subquery, substring, sum, table, tokenize, transform, transpile, trim, union, unionAll, update, upper, validate, validateWithSchema, walk };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polyglot-sql/sdk",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "SQL dialect translator powered by WebAssembly",
   "type": "module",
   "main": "./dist/index.cjs",