sql-typechecker 0.0.18 → 0.0.21

package/out/cli.js

@@ -4110,7 +4110,7 @@ var require_lodash = __commonJS((exports2, module2) => {
       function isNull(value2) {
         return value2 === null;
       }
-      function isNil(value2) {
+      function isNil2(value2) {
         return value2 == null;
       }
       function isNumber(value2) {
@@ -5174,7 +5174,7 @@ var require_lodash = __commonJS((exports2, module2) => {
       lodash.isMatchWith = isMatchWith;
       lodash.isNaN = isNaN2;
       lodash.isNative = isNative;
-      lodash.isNil = isNil;
+      lodash.isNil = isNil2;
       lodash.isNull = isNull;
       lodash.isNumber = isNumber;
       lodash.isObject = isObject;
@@ -226429,8 +226429,8 @@ ${fromBody}`;
           jsxMode = true;
           forceNoIndent = true;
           const wrap = (doc2) => [ifBreak("("), indent([softline, doc2]), softline, ifBreak(")")];
-          const isNil = (node2) => node2.type === "NullLiteral" || node2.type === "Literal" && node2.value === null || node2.type === "Identifier" && node2.name === "undefined";
-          parts.push(" ? ", isNil(consequentNode) ? print(consequentNodePropertyName) : wrap(print(consequentNodePropertyName)), " : ", alternateNode.type === node.type || isNil(alternateNode) ? print(alternateNodePropertyName) : wrap(print(alternateNodePropertyName)));
+          const isNil2 = (node2) => node2.type === "NullLiteral" || node2.type === "Literal" && node2.value === null || node2.type === "Identifier" && node2.name === "undefined";
+          parts.push(" ? ", isNil2(consequentNode) ? print(consequentNodePropertyName) : wrap(print(consequentNodePropertyName)), " : ", alternateNode.type === node.type || isNil2(alternateNode) ? print(alternateNodePropertyName) : wrap(print(alternateNodePropertyName)));
         } else {
           const part = [line, "? ", consequentNode.type === node.type ? ifBreak("", "(") : "", align(2, print(consequentNodePropertyName)), consequentNode.type === node.type ? ifBreak("", ")") : "", line, ": ", alternateNode.type === node.type ? print(alternateNodePropertyName) : align(2, print(alternateNodePropertyName))];
           parts.push(parent.type !== node.type || parent[alternateNodePropertyName] === node || isParentTest ? part : options.useTabs ? dedent(indent(part)) : align(Math.max(0, options.tabWidth - 2), part));
@@ -235895,13 +235895,14 @@ ${text}`;
 
 // src/cli.ts
 var fs = __toModule(require("fs/promises"));
-var import_lodash = __toModule(require_lodash());
+var import_lodash2 = __toModule(require_lodash());
 var path = __toModule(require("path"));
 var import_pgsql_ast_parser2 = __toModule(require_lib());
 var prettier = __toModule(require_prettier());
 
 // src/typecheck.ts
 var import_assert = __toModule(require("assert"));
+var import_lodash = __toModule(require_lodash());
 var import_pgsql_ast_parser = __toModule(require_lib());
 
 // src/normalize.ts
@@ -241688,6 +241689,10 @@ var BuiltinTypes = {
   Jsonb: {
     kind: "scalar",
     name: {name: "jsonb"}
+  },
+  Null: {
+    kind: "scalar",
+    name: {name: "null"}
   }
 };
 var allNumericBuiltinTypes = [
@@ -241907,15 +241912,30 @@ function unifyCallGeneral(call, argTypes, expectedArgs, returnT) {
   return returnT;
 }
 function castScalars(e, source, target, type) {
+  const matchingCast = findMatchingCast([source.name], source, target, type);
+  if (matchingCast === null) {
+    throw new TypeMismatch(e, {expected: target, actual: source});
+  }
+}
+function findMatchingCast(visited, from, to, type) {
   const casts = builtincasts;
-  if (eqQNames(source.name, target.name)) {
-    return;
+  if (eqQNames(from.name, to.name)) {
+    return {source: from, target: to, type: "implicit"};
   } else {
-    const matchingCast = casts.find((c) => eqQNames(c.source.name, source.name) && eqQNames(c.target.name, target.name) && (c.type === type || c.type === "implicit" && type === "assignment" || c.type === "implicit" && type === "explicit"));
-    if (matchingCast) {
-      return;
+    const halfMatching = casts.filter((c) => eqQNames(c.source.name, from.name) && (c.type === type || c.type === "implicit" && type === "assignment" || c.type === "implicit" && type === "explicit") && !visited.some((v) => eqQNames(v, c.target.name)));
+    const matchingCast = halfMatching.find((c) => eqQNames(c.target.name, to.name));
+    if (!import_lodash.isNil(matchingCast)) {
+      return matchingCast;
+    } else if (type === "explicit") {
+      for (let halfM of halfMatching) {
+        const found = findMatchingCast(visited.concat(from.name), halfM.target, to, type);
+        if (!import_lodash.isNil(found)) {
+          return found;
+        }
+      }
+      return null;
     } else {
-      throw new TypeMismatch(e, {expected: target, actual: source});
+      return null;
     }
   }
 }
@@ -242029,8 +242049,12 @@ function elabSelect(g, c, s) {
             kind: "record",
             fields: fr.type.fields.map((fi) => {
               const foundNullabilityInference = inferredNullability.find((inf) => eqQNames(inf.fromName, fr.name) && inf.fieldName === fi.name?.name);
-              const t = foundNullabilityInference ? foundNullabilityInference.isNull === true ? nullify(fi.type) : unnullify(fi.type) : fi.type;
-              return {name: fi.name, type: t};
+              if (foundNullabilityInference && isNullable(fi.type)) {
+                const t = foundNullabilityInference.isNull === true ? BuiltinTypes.Null : unnullify(fi.type);
+                return {name: fi.name, type: t};
+              } else {
+                return fi;
+              }
             })
           }
         }))
@@ -242043,13 +242067,12 @@ function elabSelect(g, c, s) {
     const names = [];
     const fields = (s.columns || []).flatMap((c2) => {
       const n = c2.alias ? c2.alias : deriveNameFromExpr(c2.expr);
-      if (n === null) {
-        throw new UnableToDeriveFieldName(c2.expr);
-      }
-      if (names.includes(n.name)) {
-        throw new DuplicateFieldNames(c2.expr, n.name);
+      if (!import_lodash.isNil(n)) {
+        if (names.includes(n.name)) {
+          throw new DuplicateFieldNames(c2.expr, n.name);
+        }
+        names.push(n.name);
       }
-      names.push(n.name);
       const t = elabExpr(g, newC, c2.expr);
       if (t.kind === "record") {
         if (t.fields.length === 0) {
@@ -242468,12 +242491,15 @@ var ColumnsMismatch = class extends ErrorWithLocation {
 };
 var KindMismatch = class extends ErrorWithLocation {
   constructor(e, type, errormsg) {
-    super(e._location, `KindMismatch: ${e}: ${type}: ${errormsg}}`);
-  }
-};
-var UnableToDeriveFieldName = class extends ErrorWithLocation {
-  constructor(e) {
-    super(e._location, `Unable to derive field name for expression ${e}, please provide an alias with <expr> AS <name>`);
+    super(e._location, `
+KindMismatch:
+${import_pgsql_ast_parser.toSql.expr(e)}
+
+${errormsg}}
+
+Type: 
+${JSON.stringify(type)}
+`);
   }
 };
 var DuplicateFieldNames = class extends ErrorWithLocation {
@@ -242510,6 +242536,22 @@ ${JSON.stringify(ts.actual)}}
     this.mess = mess;
   }
 };
+var CannotCast = class extends ErrorWithLocation {
+  constructor(e, ts) {
+    super(e._location, `
+Cannot cast:
+${JSON.stringify(ts.from)}
+
+to
+${JSON.stringify(ts.to)}}
+
+in expr:
+${import_pgsql_ast_parser.toSql.expr(e)}
+`);
+    this.from = ts.from;
+    this.to = ts.to;
+  }
+};
 var warnings = [];
 function registerWarning(e, message) {
   warnings.push([e, message]);
@@ -242814,6 +242856,9 @@ function elabCall(g, c, e) {
   if (eqQNames(e.function, {name: "nextval"})) {
     return unifyCallGeneral(e, argTypes, [BuiltinTypes.Text], BuiltinTypes.Bigint);
   }
+  if (eqQNames(e.function, {name: "now"})) {
+    return unifyCallGeneral(e, argTypes, [], BuiltinTypes.Timestamp);
+  }
   if (eqQNames(e.function, {name: "any"}) || eqQNames(e.function, {name: "some"}) || eqQNames(e.function, {name: "all"})) {
     if (e.args.length !== 1) {
       throw new InvalidArguments(e, e.function, argTypes);
@@ -242863,7 +242908,6 @@ function elabCall(g, c, e) {
     return unifyCallGeneral(e, argTypes, [BuiltinTypes.AnyScalar], BuiltinTypes.Boolean);
   }
   if (eqQNames(e.function, {name: "coalesce"}) || eqQNames(e.function, {name: "nullif"})) {
-    debugger;
     if (e.args.length === 0) {
       throw new InvalidArguments(e, e.function, []);
     }
@@ -243051,7 +243095,11 @@ function elabExpr(g, c, e) {
   } else if (e.type === "cast") {
     const operandT = elabExpr(g, c, e.operand);
     const toT = mkType(e.to, []);
-    cast(e, operandT, nullify(toT), "explicit");
+    try {
+      cast(e, operandT, toT, "explicit");
+    } catch (err) {
+      throw new CannotCast(e, {from: operandT, to: toT});
+    }
     if (isNullable(operandT)) {
       return toT;
     } else {
@@ -243276,7 +243324,7 @@ function functionToTypescript(f) {
       return "";
     }
   }
-  const asExpression = f.returns.kind === "record" ? ` AS ${f.name.name}(${f.returns.fields.map((f2) => (f2.name?.name || "") + " " + showTypeDroppingNullable(f2.type)).join(", ")})` : "";
+  const asExpression = f.returns.kind === "record" ? ` AS ${f.name.name}(${f.returns.fields.map((f2, i) => (f2.name?.name || "field" + i) + " " + showTypeDroppingNullable(f2.type)).join(", ")})` : "";
   const recreatedSqlFunctionStatement = `
 CREATE FUNCTION ${f.name.name}(${argsForCreateFunction}) RETURNS ${f.multipleRows ? "SETOF " : ""}${f.returns.kind === "record" ? "RECORD" : f.returns.kind === "void" ? "void" : showTypeDroppingNullable(f.returns)} AS
 $$${f.code}$$ LANGUAGE ${f.language};
@@ -243342,15 +243390,15 @@ ${f.name?.name}?: ${showTypeAsTypescriptType(f.type)}`).join(",");
     const insert = `
 export async function insert(pool: Pool, row: {${inputRow}}): Promise<{${primaryKeySingleCol.name.name}: ${showTypeAsTypescriptType(primaryKeySingleCol.type)}} | null>{
 
-  const providedFields = Object.keys(row);
+  const providedFields = Object.keys(row)  as (keyof typeof row)[];
 
   const res = await pool.query({
   text: "INSERT INTO ${showQName(table.name)} (" + (providedFields.join(", ")) + ") VALUES (" + providedFields.map((_, i) => "$" + (i + 1)).join(", ") +") RETURNING ${primaryKeySingleCol.name.name}",
   values: providedFields.map(f => row[f]),
   rowMode: "array",
   });
-  if (res && res[0]){
-    return {${primaryKeySingleCol.name.name}: res[0][0]};
+  if (res && res.rows[0]){
+    return {${primaryKeySingleCol.name.name}: res.rows[0][0]};
   } else {
     return null;
   }
@@ -243360,12 +243408,12 @@ ${f.name?.name}?: ${showTypeAsTypescriptType(f.type)}`).join(",");
     const update = `
 export async function update(pool: Pool, pk: {${primaryKeySingleCol.name.name}: ${showTypeAsTypescriptType(primaryKeySingleCol.type)}}, row: {${inputRowForUpdate}}): Promise<null>{
 
-  const providedFields = Object.keys(row);
+  const providedFields = Object.keys(row) as (keyof typeof row)[] ;
   if (providedFields.length === 0){ return null; }
 
   await pool.query({
   text: "UPDATE ${showQName(table.name)} SET " + providedFields.map((f, i) => f + " = $" + (i + 2)).join(", ") + " WHERE ${primaryKeySingleCol.name.name} = $1",
-values: [pk.${primaryKeySingleCol.name.name}].concat(providedFields.map(f => row[f])),
+values: ([pk.${primaryKeySingleCol.name.name}] as any[]).concat(providedFields.map(f => row[f])),
   rowMode: "array",
   });
   return null;
@@ -243448,6 +243496,12 @@ async function go() {
   }
   await fs.appendFile(domainFile, `
 `, "utf-8");
+  const tablesIndexFile = path.format({
+    dir: outDir,
+    name: "tables",
+    ext: ".ts"
+  });
+  await prepOutFile(tablesIndexFile);
   await fs.mkdir(path.join(outDir, "tables"), {recursive: true});
   for (let table of g.tables) {
     const tableOutFile = path.format({
@@ -243459,6 +243513,8 @@ async function go() {
     const text = genCrudOperations(table);
     await fs.appendFile(tableOutFile, mkImportDomainsStatement(g.domains, tableOutFile, domainFile), "utf8");
     await fs.appendFile(tableOutFile, prettier.format(text, {parser: "typescript"}), "utf-8");
+    await fs.appendFile(tablesIndexFile, `export * as ${table.name.name} from "./tables/${table.name.name}";
+`);
   }
   for (let f of allStatements) {
     const createFunctionStatements = f.statements.filter(isCreateFunctionStatement);
@@ -243480,14 +243536,13 @@ async function go() {
         await fs.appendFile(functionsOutFile, writing, "utf-8");
       } catch (err) {
         if (err instanceof ErrorWithLocation && err.l !== void 0) {
-          debugger;
           const found = findCode(st.code || "", err.l);
           if (found) {
             console.error("");
-            console.error(`Found error at line ${found.lineNumber}`);
+            console.error(`Typechecking error`);
             console.error("");
             console.error(found.line);
-            console.error(import_lodash.repeat(" ", found.range[0]) + import_lodash.repeat("^", found.range[1] - found.range[0]));
+            console.error(import_lodash2.repeat(" ", found.range[0]) + import_lodash2.repeat("^", found.range[1] - found.range[0]));
           }
         }
         console.error(err instanceof Error ? err.message : JSON.stringify(err));
@@ -243510,7 +243565,7 @@ function findCode(s, l) {
         lineNumber,
         range: [
           l.start - counted,
-          import_lodash.min([lineLength, l.end - counted]) || lineLength
+          import_lodash2.min([lineLength, l.end - counted]) || lineLength
         ]
       };
     }