utils

Author: pyramation

.github/workflows/run-tests.yaml

@@ -22,5 +22,8 @@ jobs:
       - name: proto-parser
         run: cd ./packages/proto-parser && yarn test
 
+      - name: utils
+        run: cd ./packages/utils && yarn test
+
       - name: transform
         run: cd ./packages/transform && yarn test

__fixtures__/generated/generated.json

@@ -21148,6 +21148,8 @@
   "misc/cascades-23.sql": "DROP TRANSFORM IF EXISTS FOR some_type LANGUAGE plpgsql CASCADE",
   "misc/cascades-24.sql": "ALTER TABLE some_table DROP COLUMN some_column CASCADE",
   "misc/cascades-25.sql": "ALTER TABLE some_table DROP CONSTRAINT some_constraint CASCADE",
+  "misc/booleans-cast-1.sql": "SELECT * FROM myschema.mytable WHERE a = TRUE",
+  "misc/booleans-cast-2.sql": "SELECT * FROM myschema.mytable WHERE a = CAST('t' AS boolean)",
   "latest/postgres/create_view-1.sql": "CREATE FUNCTION interpt_pp(path, path)\n    RETURNS point\n    AS 'regresslib'\n    LANGUAGE C STRICT",
   "latest/postgres/create_view-2.sql": "CREATE TABLE real_city (\n\tpop\t\t\tint4,\n\tcname\t\ttext,\n\toutline \tpath\n)",
   "latest/postgres/create_view-3.sql": "COPY real_city FROM 'filename'",

__fixtures__/generated/upstream-diff.json

@@ -1071,6 +1071,18 @@
     "original": "DROP SUBSCRIPTION IF EXISTS some_sub CASCADE",
     "upstream": "DROP SUBSCRIPTION IF EXISTS some_sub"
   },
+  "misc/booleans-cast-1.sql": {
+    "original": "SELECT * FROM myschema.mytable WHERE a = TRUE",
+    "upstream": "SELECT * FROM myschema.mytable WHERE a = false"
+  },
+  "misc/booleans-cast-2.sql": {
+    "original": "SELECT * FROM myschema.mytable WHERE a = CAST('t' AS boolean)",
+    "upstream": "SELECT * FROM myschema.mytable WHERE a = true"
+  },
+  "misc/booleans-cast-3.sql": {
+    "original": "SELECT * FROM myschema.mytable WHERE a = 't'::boolean",
+    "upstream": "SELECT * FROM myschema.mytable WHERE a = true"
+  },
   "latest/postgres/create_view-1.sql": {
     "original": "CREATE FUNCTION interpt_pp(path, path)\n    RETURNS point\n    AS 'regresslib'\n    LANGUAGE C STRICT",
     "upstream": "CREATE FUNCTION interpt_pp(path, path) RETURNS point AS $$regresslib$$ LANGUAGE c CALLED ON NULL INPUT"

__fixtures__/kitchen-sink/misc/booleans-cast.sql

@@ -0,0 +1,3 @@
+ SELECT * FROM myschema.mytable WHERE a = TRUE;
+ SELECT * FROM myschema.mytable WHERE a = CAST('t' AS boolean);
+ SELECT * FROM myschema.mytable WHERE a = 't'::boolean;

packages/deparser/__tests__/kitchen-sink/misc-booleans-cast.test.ts

@@ -0,0 +1,10 @@
+
+import { FixtureTestUtils } from '../../test-utils';
+const fixtures = new FixtureTestUtils();
+
+it('misc-booleans-cast', async () => {
+  await fixtures.runFixtureTests([
+  "misc/booleans-cast-1.sql",
+  "misc/booleans-cast-2.sql"
+]);
+});

packages/utils/__test__/__snapshots__/utils.test.ts.snap

@@ -1,25 +1,6 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
-exports[`dynamic creation of tables 1`] = `
-"CREATE TABLE users (
- 	id int PRIMARY KEY,
-	username text,
-	email text UNIQUE,
-	created_at timestamp NOT NULL 
-)"
-`;
-
-exports[`getEnumValue snapshots 1`] = `"AEXPR_OP"`;
-
-exports[`getEnumValue snapshots 2`] = `"AEXPR_OP_ANY"`;
-
-exports[`getEnumValue snapshots 3`] = `"AEXPR_OP_ALL"`;
-
-exports[`getEnumValue snapshots 4`] = `"AEXPR_DISTINCT"`;
-
-exports[`getEnumValue snapshots 5`] = `"AEXPR_NOT_DISTINCT"`;
-
-exports[`getEnumValue snapshots 6`] = `"AEXPR_NULLIF"`;
+exports[`dynamic creation of tables 1`] = `"CREATE TABLE users (id int PRIMARY KEY, username text, email text UNIQUE, created_at timestamp NOT NULL)"`;
 
 exports[`simple SelectStmt 1`] = `
 {

packages/utils/__test__/utils.test.ts.no.run renamed to packages/utils/__test__/utils.test.ts

@@ -1,24 +1,18 @@
-import * as u from '../src';
-import ast, { SelectStmt, RangeVar } from '../src';
+import * as t from '../src';
+import { RangeVar, SelectStmt } from '@pgsql/types';
 import { deparse } from 'pgsql-deparser';
 
-it('getEnumValue snapshots', () => {
-  for (let i = 0; i <= 5; i++) {
-    expect(u.getEnumValue('A_Expr_Kind', i)).toMatchSnapshot();
-  }
-});
-
 it('simple SelectStmt', () => {
-  const stmt: SelectStmt = ast.selectStmt({
+  const stmt: { SelectStmt: SelectStmt } = t.nodes.selectStmt({
     targetList: [
-      ast.resTarget({
-        val: ast.columnRef({
-          fields: [ast.aStar()]
+      t.nodes.resTarget({
+        val: t.nodes.columnRef({
+          fields: [t.nodes.aStar()]
         })
       })
     ],
     fromClause: [
-      ast.rangeVar({
+      t.nodes.rangeVar({
         relname: 'some_table',
         inh: true,
         relpersistence: 'p'
@@ -28,44 +22,43 @@ it('simple SelectStmt', () => {
     op: 'SETOP_NONE'
   });
 
-  // @ts-ignore (because of optional args)
-  stmt.SelectStmt.fromClause[0].RangeVar.relname = 'another_table';
+  (stmt.SelectStmt.fromClause[0] as {RangeVar: RangeVar}).RangeVar.relname = 'another_table';
 
   expect(stmt).toMatchSnapshot();
   expect(deparse(stmt, {})).toMatchSnapshot();
 });
 
 it('SelectStmt with WHERE clause', () => {
-  const selectStmt: SelectStmt = ast.selectStmt({
+  const selectStmt: { SelectStmt: SelectStmt } = t.nodes.selectStmt({
     targetList: [
-      ast.resTarget({
-        val: ast.columnRef({
-          fields: [ast.aStar()]
+      t.nodes.resTarget({
+        val: t.nodes.columnRef({
+          fields: [t.nodes.aStar()]
         })
       })
     ],
     fromClause: [
-      ast.rangeVar({
+      t.nodes.rangeVar({
         schemaname: 'myschema',
         relname: 'mytable',
         inh: true,
         relpersistence: 'p'
       })
     ],
-    whereClause: ast.aExpr({
+    whereClause: t.nodes.aExpr({
       kind: 'AEXPR_OP',
-      name: [ast.string({ str: '=' })],
-      lexpr: ast.columnRef({
-        fields: [ast.string({ str: 'a' })]
+      name: [t.nodes.string({ sval: '=' })],
+      lexpr: t.nodes.columnRef({
+        fields: [t.nodes.string({ sval: 'a' })]
       }),
-      rexpr: ast.typeCast({
-        arg: ast.aConst({
-          val: ast.string({ str: 't' })
+      rexpr: t.nodes.typeCast({
+        arg: t.nodes.aConst({
+          sval: t.ast.string({ sval: 't' })
         }),
-        typeName: ast.typeName({
+        typeName: t.ast.typeName({
           names: [
-            ast.string({ str: 'pg_catalog' }),
-            ast.string({ str: 'bool' })
+            t.nodes.string({ sval: 'pg_catalog' }),
+            t.nodes.string({ sval: 'bool' })
           ],
           typemod: -1
         })
@@ -74,7 +67,8 @@ it('SelectStmt with WHERE clause', () => {
     limitOption: 'LIMIT_OPTION_DEFAULT',
     op: 'SETOP_NONE'
   });
-  expect(deparse(selectStmt, {})).toEqual('SELECT * FROM myschema.mytable WHERE a = TRUE');
+  
+  expect(deparse(selectStmt, {})).toEqual(`SELECT * FROM myschema.mytable WHERE a = CAST('t' AS boolean)`);
 });
 
 it('dynamic creation of tables', () => {
@@ -90,19 +84,19 @@ it('dynamic creation of tables', () => {
   };
 
   // Construct the CREATE TABLE statement
-  const createStmt = ast.createStmt({
-    relation: ast.rangeVar({ 
+  const createStmt = t.nodes.createStmt({
+    relation: t.ast.rangeVar({ 
       relname: schema.tableName,
       inh: true,
       relpersistence: 'p'
-    }).RangeVar as RangeVar, // special case due to PG AST
-    tableElts: schema.columns.map(column => ast.columnDef({
+    }),
+    tableElts: schema.columns.map(column => t.nodes.columnDef({
       colname: column.name,
-      typeName: ast.typeName({
-        names: [ast.string({ str: column.type })]
+      typeName: t.ast.typeName({
+        names: [t.nodes.string({ sval: column.type })]
       }),
       constraints: column.constraints?.map(constraint =>
-        ast.constraint({
+        t.nodes.constraint({
           contype: constraint === "PRIMARY KEY" ? "CONSTR_PRIMARY" : constraint === "UNIQUE" ? "CONSTR_UNIQUE" : "CONSTR_NOTNULL"
         })
       )

packages/utils/package.json

@@ -31,7 +31,8 @@
     "test:watch": "jest --watch"
   },
   "devDependencies": {
-    "pg-proto-parser": "^1.28.2"
+    "pg-proto-parser": "^1.28.2",
+    "pgsql-deparser": "^17.6.2"
   },
   "dependencies": {
     "@pgsql/types": "^17.5.3",

packages/utils/scripts/pg-proto-parser.ts

@@ -9,11 +9,26 @@ const options: PgProtoParserOptions = {
   types: {
     enabled: false
   },
+  enums: {
+    enabled: false,
+  },
   utils: {
+    enums: {
+      enabled: false,
+    },
     astHelpers: {
       enabled: true,
-      typesSource: '@pgsql/types'
+      typesSource: '@pgsql/types',
+    },
+    wrappedAstHelpers: {
+      enabled: true,
+      filename: 'wrapped.ts'
     }
+  },
+  runtimeSchema: {
+    enabled: true,
+    filename: 'runtime-schema.ts',
+    format: 'typescript'
   }
 };
 const parser = new PgProtoParser(inFile, options);