sql-typechecker 0.0.52 → 0.0.54

package/out/cli.js

@@ -241354,7 +241354,14 @@ var builtinoperatorsFromSchema = [
 var builtinoperators = builtinoperatorsFromSyntax.concat(builtinoperatorsFromSchema);
 
 // src/builtinunaryoperators.ts
-var builtinunaryoperatorsFromSyntax = [];
+var builtinunaryoperatorsFromSyntax = [
+  {
+    name: {name: "NOT"},
+    operand: {kind: "scalar", name: {name: "boolean"}},
+    result: {kind: "scalar", name: {name: "boolean"}},
+    description: ""
+  }
+];
 var builtinunaryoperatorsFromSchema = [
   {
     name: {name: "!"},
@@ -241983,6 +241990,16 @@ function checkType(g, l, name) {
       }
     };
   }
+  const foundEnum = g.enums.find((d) => d.name.name === name);
+  if (foundEnum) {
+    return {
+      kind: "scalar",
+      name: {_location: l, name},
+      isEnum: {
+        values: foundEnum.values
+      }
+    };
+  }
   const builtintype = Object.keys(BuiltinTypes).concat(["bytea"]).find((b) => b.toLowerCase() === name);
   if (builtintype) {
     return {
@@ -242839,6 +242856,12 @@ function elabBinaryOp(g, c, e) {
     right: {kind: "scalar", name: d.name},
     result: {kind: "scalar", name: {name: "boolean"}},
     description: "equal"
+  }))).concat(g.enums.map((d) => ({
+    name: {schema: "pg_catalog", name: "="},
+    left: {kind: "scalar", name: d.name},
+    right: {kind: "scalar", name: d.name},
+    result: {kind: "scalar", name: {name: "boolean"}},
+    description: "equal"
   }))).filter(function(op) {
     return eqQNames({
       name: normalizeOperatorName(e.op),
@@ -243235,7 +243258,7 @@ function elabExpr(g, c, e) {
 function inferNullability(c, e) {
   if (e.type === "unary") {
     if (e.op === "NOT") {
-      return inferNullability(c, e).map((judg) => ({
+      return inferNullability(c, e.operand).map((judg) => ({
         ...judg,
         isNull: !judg.isNull
       }));
@@ -243290,6 +243313,14 @@ function parseSetupScripts(g, ast) {
           realtype: mkType(acc, a.dataType, [{type: "not null"}])
         })
       };
+    } else if (a.type === "create enum") {
+      return {
+        ...acc,
+        enums: acc.enums.concat({
+          name: a.name,
+          values: a.values.map((v) => v.value)
+        })
+      };
     } else {
       return acc;
     }
@@ -243349,7 +243380,9 @@ function showTypeAsTypescriptType(t) {
     } else if (t.kind === "nullable") {
       return showTypeAsTypescriptType(t.typevar) + " | null";
     } else if (t.kind === "scalar") {
-      if ([
+      if (t.domain) {
+        return `types.${t.name.name}`;
+      } else if ([
         "numeric",
         "bigint",
         "smallint",
@@ -243371,6 +243404,8 @@ function showTypeAsTypescriptType(t) {
         return "LocalTime";
       } else if (t.name.name === "timestamp without time zone" || t.name.name === "timestamp") {
         return "LocalDateTime";
+      } else if (t.isEnum) {
+        return "types." + t.name.name;
       } else {
         return t.name.name;
       }
@@ -243385,7 +243420,7 @@ function showTypeAsTypescriptType(t) {
 }
 function genDeserializeSimpleT(t, literalVar) {
   if (t.kind === "array") {
-    return `parseArray(${literalVar}, (el: any) => ${genDeserializeSimpleT(t.typevar, "el")})`;
+    return `${literalVar} === null ? [] : (Array.isArray(${literalVar}) ? ${literalVar} : parseArray(${literalVar})).map((el: any) => ${genDeserializeSimpleT(t.typevar, "el")})`;
   } else if (t.kind === "nullable") {
     const inner = genDeserializeSimpleT(t.typevar, literalVar);
     if (inner === literalVar) {
@@ -243399,7 +243434,7 @@ function genDeserializeSimpleT(t, literalVar) {
     return "({" + t.record.fields.map((f) => `${f.name?.name || "?"}: ${genDeserializeSimpleT(f.type, literalVar + '["' + f.name?.name + '"]')}`).join(",\n") + "})";
   } else if (t.kind === "scalar") {
     if (t.domain) {
-      return `${genDeserializeSimpleT(t.domain.realtype, literalVar)} as ${t.name.name}`;
+      return `${genDeserializeSimpleT(t.domain.realtype, literalVar)} as types.${t.name.name}`;
     }
     if (t.name.name === "date") {
       return `LocalDate.parse(${literalVar})`;
@@ -243479,6 +243514,11 @@ export async function ${f.name.name}(pool: Pool, args: ${argsType})
 function genDomain(dom) {
   return `export type ${dom.name.name} = ${showTypeAsTypescriptType(dom.realtype)} & { readonly __tag: "${dom.name.name}" };`;
 }
+function genEnum(enu) {
+  return `export type ${enu.name.name} =
+  | ${enu.values.map((v) => `"${v}"`).join("\n  | ")};
+`;
+}
 function getImports() {
   return `
 import type { Pool } from "pg";
@@ -243621,7 +243661,7 @@ async function go() {
     throw new Error("Please provide at least one SQL file with flags -f/--file or -d/--dir");
   }
   const allStatements = [];
-  let g = {tables: [], views: [], domains: []};
+  let g = {tables: [], views: [], domains: [], enums: []};
   for (let sqlFile of allSqlFiles) {
     const fileContents = await fs.readFile(sqlFile, "utf-8");
     const statements = import_trader_pgsql_ast_parser2.parse(fileContents, {
@@ -243631,6 +243671,7 @@ async function go() {
     try {
       g = parseSetupScripts(g, statements);
     } catch (err) {
+      console.error("Error in setup script");
       console.error("---------------------------------------------");
       if (err instanceof ErrorWithLocation && err.l !== void 0) {
         const found = findCode(fileContents, err.l);
@@ -243645,20 +243686,24 @@ async function go() {
       console.error(err instanceof Error ? err.message : JSON.stringify(err));
       console.error("---------------------------------------------");
       console.error("");
+      process.exit(1);
     }
   }
   const outDir = path.resolve(process.cwd(), outArg);
   await fs.mkdir(outDir, {recursive: true});
-  const domainFile = path.format({
+  const typesFile = path.format({
     dir: outDir,
-    name: "domains",
+    name: "types",
     ext: ".ts"
   });
-  await prepOutFile(domainFile);
+  await prepOutFile(typesFile);
   for (let dom of g.domains) {
-    await fs.appendFile(domainFile, genDomain(dom) + "\n", "utf-8");
+    await fs.appendFile(typesFile, genDomain(dom) + "\n", "utf-8");
+  }
+  for (let enu of g.enums) {
+    await fs.appendFile(typesFile, genEnum(enu) + "\n", "utf-8");
   }
-  await fs.appendFile(domainFile, `
+  await fs.appendFile(typesFile, `
 `, "utf-8");
   const tablesIndexFile = path.format({
     dir: outDir,
@@ -243675,7 +243720,7 @@ async function go() {
     });
     await prepOutFile(tableOutFile);
     const text = genCrudOperations(table);
-    await fs.appendFile(tableOutFile, mkImportDomainsStatement(g.domains, tableOutFile, domainFile), "utf8");
+    await fs.appendFile(tableOutFile, mkImportDomainsStatement(g.domains, tableOutFile, typesFile), "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}";
 `);
@@ -243689,7 +243734,7 @@ async function go() {
       ext: ".ts"
     });
     const functionsOutFile = await prepOutFile(outFileName);
-    await fs.appendFile(outFileName, mkImportDomainsStatement(g.domains, outFileName, domainFile), "utf8");
+    await fs.appendFile(outFileName, mkImportDomainsStatement(g.domains, outFileName, typesFile), "utf8");
     for (let st of createFunctionStatements) {
       try {
         const res = doCreateFunction(g, {decls: [], froms: []}, st);
@@ -243774,11 +243819,10 @@ function mkImportDomainsStatement(domains, thisFile, domainFile) {
   const p = path.relative(path.dirname(thisFile), path.dirname(domainFile));
   const formatted = path.format({
     dir: p || ".",
-    name: "domains",
+    name: "types",
     ext: ""
   });
-  const doms = domains.map((d) => d.name.name).join(", ");
-  return `import {${doms}} from "${formatted}";
+  return `import * as types from "${formatted}";
 
 `;
 }