sql-typechecker 0.0.7 → 0.0.10

package/src/codegen.ts

@@ -1,384 +0,0 @@
-import { Name, QName } from "pgsql-ast-parser";
-import {
-  checkAllCasesHandled,
-  functionType,
-  JsonKnownT,
-  RecordT,
-  showQName,
-  showSqlType,
-  SimpleT,
-  Type,
-  VoidT,
-} from "./typecheck";
-
-export function showTypeAsTypescriptType(t: Type): string {
-  if (t.kind === "record") {
-    return (
-      "{" +
-      t.fields
-        .map(
-          (f) =>
-            (f.name === null ? `"?": ` : `"${f.name.name}": `) +
-            showTypeAsTypescriptType(f.type)
-        )
-        .join(", ") +
-      "}"
-    );
-  } else {
-    if (t.kind === "array") {
-      return "(" + showTypeAsTypescriptType(t.typevar) + ")" + "[]";
-    } else if (t.kind === "nullable") {
-      return showTypeAsTypescriptType(t.typevar) + " | null";
-    } else if (t.kind === "scalar") {
-      if (
-        ["numeric", "bigint", "smallint", "integer", "real", "double"].includes(
-          t.name.name
-        )
-      ) {
-        return "number";
-      } else if (
-        ["text", "name", "char", "character", "varchar", "nvarchar"].includes(
-          t.name.name
-        )
-      ) {
-        return "string";
-      } else if (["bytea"].includes(t.name.name)) {
-        return "Buffer";
-      } else if (t.name.name === "date") {
-        return "LocalDate";
-      } else if (t.name.name === "time") {
-        return "LocalTime";
-      } else if (
-        t.name.name === "timestamp without time zone" ||
-        t.name.name === "timestamp"
-      ) {
-        return "LocalDateTime";
-      } else {
-        return t.name.name;
-      }
-    } else if (t.kind === "jsonknown") {
-      return (
-        "{\n" +
-        t.record.fields
-          .map((f) => `  ${f.name?.name}: ${showTypeAsTypescriptType(f.type)}`)
-          .join(",\n") +
-        "\n}"
-      );
-    } else if (t.kind === "anyscalar") {
-      return "anyscalar";
-    } else {
-      return checkAllCasesHandled(t);
-    }
-  }
-}
-
-function genDeserializeSimpleT(t: SimpleT, literalVar: string): string {
-  if (t.kind === "array") {
-    return `${literalVar}.map((el: any) => ${genDeserializeSimpleT(
-      t.typevar as SimpleT,
-      "el"
-    )})`;
-  } else if (t.kind === "nullable") {
-    const inner = genDeserializeSimpleT(t.typevar as SimpleT, literalVar);
-    if (inner === literalVar) {
-      return inner;
-    } else {
-      return `${literalVar} === null ? (${inner}) : null`;
-    }
-  } else if (t.kind === "anyscalar") {
-    return literalVar;
-  } else if (t.kind === "jsonknown") {
-    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.name.name === "date") {
-      return `LocalDate.parse(${literalVar})`;
-    } else if (t.name.name === "time") {
-      return `LocalTime.parse(${literalVar})`;
-    } else if (t.name.name === "timestamp with time zone") {
-      return `Instant.parse(${literalVar})`;
-    } else if (
-      t.name.name === "timestamp without time zone" ||
-      t.name.name === "timestamp"
-    ) {
-      return `LocalDateTime.parse(${literalVar})`;
-    } else {
-      return literalVar;
-    }
-  } else {
-    return checkAllCasesHandled(t);
-  }
-}
-
-function genDeserialization(
-  returnType: SimpleT | RecordT | VoidT,
-  literalVar: string
-) {
-  if (returnType.kind === "void") {
-    return literalVar;
-  } else if (returnType.kind === "record") {
-    return (
-      "({" +
-      returnType.fields
-        .map(
-          (f, i) =>
-            `${f.name?.name || "?"}: ${genDeserializeSimpleT(
-              f.type,
-              literalVar + "[" + i + "]"
-            )}`
-        )
-        .join(",\n") +
-      "})"
-    );
-  } else {
-    `function deserialize(cells: unknown[]): any{
-return ${genDeserializeSimpleT(returnType, "cells[0]")};
-}`;
-  }
-}
-
-export function functionToTypescript(f: functionType): string {
-  const returnTypeAsString =
-    f.returns.kind === "void"
-      ? "void"
-      : showTypeAsTypescriptType(f.returns) +
-        (f.multipleRows ? "[]" : " | undefined");
-
-  const argsType =
-    "{" +
-    f.inputs
-      .map((k) => {
-        const paramTypeAsString = showTypeAsTypescriptType(k.type);
-
-        // console.log(`Param \$${k.name.name}:\n`, paramTypeAsString, "\n");
-        return k.name.name + ": " + paramTypeAsString;
-      })
-      .join(", ") +
-    "}";
-
-  const argsAsList = f.inputs.map((i) => "args." + i.name.name).join(", ");
-
-  const argsForCreateFunction = f.inputs
-    .map((k) => k.name.name + " " + showSqlType(k.type))
-    .join(", ");
-
-  function showTypeDroppingNullable(t: SimpleT | JsonKnownT): string {
-    if (t.kind === "nullable") {
-      return showTypeDroppingNullable(t.typevar);
-    } else if (t.kind === "array") {
-      return showTypeDroppingNullable(t.typevar) + "[]";
-    } else if (t.kind === "anyscalar") {
-      return "anyscalar";
-    } else if (t.kind === "scalar") {
-      return t.name.name;
-    } else if (t.kind === "jsonknown") {
-      return "json";
-    } else {
-      return "";
-    }
-  }
-
-  const asExpression =
-    f.returns.kind === "record"
-      ? ` AS ${f.name.name}(${f.returns.fields
-          .map(
-            (f) => (f.name?.name || "") + " " + showTypeDroppingNullable(f.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};
-`;
-
-  const funcInvocation = `${f.name.name}(${f.inputs.map(
-    (inp, i) => "$" + (i + 1) + "::" + showTypeDroppingNullable(inp.type)
-  )})${asExpression}`;
-
-  return `
-export async function ${f.name.name}(pool: Pool, args: ${argsType})
-  : Promise<${returnTypeAsString}>{
-
-  const res = await pool.query({
-    text: "SELECT * FROM ${funcInvocation}",
-    values: [${argsAsList}],
-    rowMode: "array",
-  });
-  const rows = res.rows.map(row => ${genDeserialization(f.returns, "row")});
-  debugger;
-  return rows${f.multipleRows ? "" : "[0]"};
-  }
-`;
-}
-
-export function genDomain(dom: {
-  readonly name: QName;
-  readonly type: SimpleT;
-}): string {
-  return `export type ${dom.name.name} = ${showTypeAsTypescriptType(
-    dom.type
-  )} & { readonly __tag: "${dom.name.name}" };`;
-}
-
-export function getImports() {
-  return `
-import type { Pool } from "pg";
-import { Instant, LocalDate, LocalTime, LocalDateTime} from "@js-joda/core";
-`;
-}
-
-export function genCrudOperations(table: {
-  readonly name: QName;
-  readonly rel: RecordT;
-  readonly primaryKey: Name[];
-  readonly defaults: Name[];
-}): string {
-  const selectAll = `
-export async function getAll(pool: Pool): Promise<${showTypeAsTypescriptType(
-    table.rel
-  )}[]>{
-
-const res = await pool.query({
-text: "SELECT * FROM ${showQName(table.name)}",
-values: [],
-rowMode: "array",
-});
-const rows = res.rows.map(row => ${genDeserialization(table.rel, "row")});
-return rows;
-}`;
-
-  const primaryKeySingleCol: null | { name: Name; type: SimpleT } =
-    (function getPrimaryKey() {
-      if (table.primaryKey.length === 1) {
-        return {
-          name: table.primaryKey[0],
-          type: table.rel.fields.find(
-            (f) => f.name?.name === table.primaryKey[0].name
-          )?.type!,
-        };
-      } else {
-        return null;
-      }
-    })();
-
-  if (!primaryKeySingleCol) {
-    return selectAll;
-  } else {
-    const relWithoutPrim = table.rel.fields.filter(
-      (f) => f.name?.name !== primaryKeySingleCol.name.name
-    );
-    const mandatoryFields = table.rel.fields.filter(
-      (c) => !table.defaults.some((def) => def.name === c.name?.name)
-    );
-    const optionalFields = table.rel.fields.filter((c) =>
-      table.defaults.some((def) => def.name === c.name?.name)
-    );
-    const inputRow =
-      mandatoryFields
-        .map(
-          (f) => `
-${f.name?.name}: ${showTypeAsTypescriptType(f.type)}`
-        )
-        .join(",") +
-      optionalFields
-        .map(
-          (f) => `
-${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 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]};
-  } else {
-    return null;
-  }
-}`;
-
-    const inputRowForUpdate = relWithoutPrim
-      .map(
-        (f) => `
-${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);
-  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])),
-  rowMode: "array",
-  });
-  return null;
-}`;
-
-    const del = `
-export async function del(pool: Pool, pk: {${
-      primaryKeySingleCol.name.name
-    }: ${showTypeAsTypescriptType(primaryKeySingleCol.type)}}): Promise<null>{
-
-await pool.query({
-text: "DELETE FROM ${showQName(table.name)} WHERE ${
-      primaryKeySingleCol.name.name
-    } = $1",
-values: [pk.${primaryKeySingleCol.name.name}],
-rowMode: "array",
-});
-return null;
-}`;
-
-    return `
-${selectAll}
-${insert}
-${update}
-${del}
-`;
-  }
-}

package/src/readme.md

@@ -1,23 +0,0 @@
-Huidige plan:
-
-We werken niet meer met positionele parameters (da's toch maar een lapmiddel, niet echt deel van Postgres) maar we gaan enkel functies declareren en die typechecken en daar (typescript) bindings van maken. 
-
-Daarmee weet je dus op voorhand welke parameters je hebt. Let bindings, from's etc, kunnen ook wel dingen in de context steken, maar da's wel beter afgelijnd. Die blocks zorgen er wel voor dat immutable Context's wel een goed idee zijn, zo volgen die de flow meteen mee.
-
-Idealiter zouden we LANGUAGE plpgsql en LANGUAGE sql moeten ondersteunen!
--> Als we beginnen met LANGUAGE sql, dan moeten we (nog) geen parser schrijven!
-
-Type inference:
-* Type is mandatory in DECLARE blocks
-* Type is mandatory in CREATE FUNCTION parameters
-* We kunnen dus aan alle Context.decls meteen een type geven. Enkel nullability heb je niet. 
-  * Of wat als we gewoon alle (user-defined) functie parameters not-nullable by default zetten, en je moet "default NULL" meegeven om ze nullable te definiëren? -> Dit is volgens mij eigenlijk het beste, maar het staat redelijk ver af van hoe Postgres het zelf doet. Op zich voor Aperi zou dit wel goed werken... YUP WE GAAN DIT DOEN
-    * Oude discussie: 
-      * Als we dat immutable willen bijhouden, dan moeten we dus ook weer heel de context de hele tijd meesleuren
-      * Als we dat mutable maken, volg je niet meer de volledige control flow, maar da's ook niet echt nodig denk ik want die moeten altijd "kloppen"
-        * Oude discussie: Moeten we parameters eerste als nullable, of als not-nullable beschouwen?
-          * Indien CALLED ON NULL INPUT (=default): Alles is nullable. (NOPE ZIE VERDER)
-          * Indien RETURNS NULL ON NULL INPUT of STRICT: Niks is nullable? . (NOPE ZIE VERDER)
-            * Eigenlijk betekent dit: Als je mij ergens een NULL geeft, geef ik NULL terug. De body wordt niet uitgevoerd. Dus inderdaad, je gaat altijd in de function body zelf not-nullable zijn! Als je zo'n functie aanroept kan je echter wel NULL terugkrijgen, als een van de argumenten NULL is. Je kan dat als speciale modifier op die functie bijhouden, en als een van de argumenten nullable is, dan is het return type ook nullable.. (NOPE ZIE VERDER)
-            * Optional parameters kunnen we wel nog ondersteunen met "myvar int default NULL". NOPE toch niet, eens STRICT kan je nooit nullable parameters binnenkrijgen. . (NOPE ZIE VERDER)
-            * Moeten we een optie voorzien (of gewoon default zo doen) dat input params aan STRICT functions nooit NULL mogen zijn?