chore: fmt

bun/fmt.js

@@ -0,0 +1,27 @@
+/** @type {(parser: string, ps: string[]) => import("bun").Subprocess} */
+const prettier = (parser, ps) =>
+  Bun.spawn(['bun', 'x', 'prettier', '--write', '--parser', parser, ...ps], {
+    stdout: 'inherit',
+    stderr: 'inherit',
+  })
+
+const procs = [
+  prettier('babel', ['./src/**/*.js', './bun/**/*.js', './.prettierrc.cjs']),
+  prettier('json', ['./package.json', './jsconfig.json']),
+  Bun.spawn(
+    [
+      'bun',
+      'x',
+      'purs-tidy',
+      'format-in-place',
+      'src/**/*.purs',
+      'test/**/*.purs',
+    ],
+    {
+      stdout: 'inherit',
+      stderr: 'inherit',
+    },
+  ),
+]
+
+await Promise.all(procs.map(p => p.exited))

jsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "types": ["bun-types"],
+    "lib": ["esnext"],
+    "target": "esnext",
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "moduleDetection": "force",
+    "jsx": "react",
+    "allowJs": true,
+    "checkJs": true,
+    "noEmit": true,
+    "strict": true
+  },
+  "include": ["src/**/*.js", "bun/**/*.js"]
+}

package.json

@@ -10,10 +10,16 @@
     "better-sqlite3": "^9.2.2",
     "github-release-notes": "^0.17.1",
     "paluh-litps": "^0.1.4",
-    "spago": "next"
+    "spago": "next",
+    "bun-types": "1.0.11",
+    "purs-tidy": "^0.10.0"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
   },
   "scripts": {
     "pretest": "paluh-litps compile --file README.md; mv README.purs test/README.purs",
-    "test": "spago test"
+    "test": "spago test",
+    "fmt": "bun bun/fmt.js"
   }
 }

src/Database/PostgreSQL/Aff.js

@@ -6,39 +6,46 @@
 // Putting this import into `PostgreSQL/Value.js` caused is a problem
 // for the web bundlers etc.
 
-import pg from 'pg';
+import pg from 'pg'
 
 // pg does strange thing converting DATE
 // value to js Date, so we have
 // to prevent this craziness
-pg.types.setTypeParser(1082 /* DATE_OID */, function(dateString) { return dateString; });
+pg.types.setTypeParser(1082 /* DATE_OID */, function (dateString) {
+  return dateString
+})
 
 export const ffiConnect = function (config) {
   return function (pool) {
     return function (onError, onSuccess) {
-            var p = pool.connect().then(function(client) {
+      var p = pool
-                onSuccess(config.right({
+        .connect()
+        .then(function (client) {
+          onSuccess(
+            config.right({
               client: client,
               done: function () {
-                        return client.release();
+                return client.release()
-                    }
+              },
-                }));
+            }),
-            }).catch(function(err) {
+          )
-                var pgError = config.nullableLeft(err);
+        })
+        .catch(function (err) {
+          var pgError = config.nullableLeft(err)
           if (pgError) {
-                    onSuccess(pgError);
+            onSuccess(pgError)
           } else {
-                    onError(err);
+            onError(err)
           }
-            });
+        })
 
       return function (cancelError, cancelerError, cancelerSuccess) {
-                p.cancel();
+        p.cancel()
-                cancelerSuccess();
+        cancelerSuccess()
-            };
+      }
-        };
+    }
-    };
+  }
-};
+}
 
 export const ffiUnsafeQuery = function (config) {
   // Either `Pool` or `Client` instance
@@ -46,34 +53,37 @@ export const ffiUnsafeQuery = function(config) {
     return function (sql) {
       return function (values) {
         return function (onError, onSuccess) {
-                    var q = dbHandle.query({
+          var q = dbHandle
+            .query({
               text: sql,
               values: values,
               rowMode: 'array',
-                    }).then(function(result) {
+            })
-                        onSuccess(config.right(result));
+            .then(function (result) {
-                    }).catch(function(err) {
+              onSuccess(config.right(result))
-                        var pgError = config.nullableLeft(err);
+            })
+            .catch(function (err) {
+              var pgError = config.nullableLeft(err)
               if (pgError) {
-                            onSuccess(pgError);
+                onSuccess(pgError)
               } else {
-                            onError(err);
+                onError(err)
               }
-                    });
+            })
 
           return function (cancelError, cancelerError, cancelerSuccess) {
-                        q.cancel();
+            q.cancel()
-                        cancelerSuccess();
+            cancelerSuccess()
-                    };
+          }
-                };
+        }
-            };
+      }
-        };
+    }
-    };
+  }
-};
+}
 
 export const ffiSQLState = function (error) {
-    return error.code || null;
+  return error.code || null
-};
+}
 
 export const ffiErrorDetail = function (error) {
   return {
@@ -94,6 +104,6 @@ export const ffiErrorDetail = function (error) {
     constraint: error.constraint || '',
     file: error.file || '',
     line: error.line || '',
-        routine: error.routine || ''
+    routine: error.routine || '',
-    };
+  }
-};
+}

src/Database/PostgreSQL/Pool.js

@@ -1,26 +1,25 @@
-import pg from 'pg';
+import pg from 'pg'
 
 export const ffiNew = function (config) {
   return function () {
-        return new pg.Pool(config);
+    return new pg.Pool(config)
-    };
+  }
-};
+}
-
 
 export const totalCount = function (pool) {
   return function () {
-    return pool.totalCount;
+    return pool.totalCount
-  };
+  }
-};
+}
 
 export const idleCount = function (pool) {
   return function () {
-    return pool.idleCount;
+    return pool.idleCount
-  };
+  }
-};
+}
 
 export const waitingCount = function (pool) {
   return function () {
-    return pool.waitingCount;
+    return pool.waitingCount
-  };
+  }
-};
+}

src/Database/PostgreSQL/Value.js

@@ -1,24 +1,24 @@
 /* global Buffer, exports, require */
 /* jshint -W097 */
 
-export const null_ = null;
+export const null_ = null
 
 export const instantToString = function (i) {
-    return new Date(i).toUTCString();
+  return new Date(i).toUTCString()
-};
+}
 
 export const instantFromString = function (Left) {
   return function (Right) {
     return function (s) {
       try {
-        return Right(Date.parse(s));
+        return Right(Date.parse(s))
       } catch (e) {
-        return Left("Date string parsing failed: \"" + s + "\", with: " + e);
+        return Left('Date string parsing failed: "' + s + '", with: ' + e)
+      }
+    }
+  }
 }
-    };
-  };
-};
 
 export const unsafeIsBuffer = function (x) {
-    return x instanceof Buffer;
+  return x instanceof Buffer
-};
+}

test/Config.purs

@@ -21,10 +21,10 @@ import Polyform.Batteries.Int (validator) as Int
 import Polyform.Validator (runValidator)
 import Type.Row (type (+))
 
-validator ∷
+validator
-  ∀ err m.
+  ∷ ∀ err m
-  Monad m ⇒
+  . Monad m
-  Env.Validator m (IntExpected + MissingValue + err) Env.Env Configuration
+  ⇒ Env.Validator m (IntExpected + MissingValue + err) Env.Env Configuration
 validator =
   { database: _, host: _, idleTimeoutMillis: _, max: _, password: _, port: _, user: _ }
     <$> Env.required "PG_DB" identity

test/Main.purs

@@ -54,10 +54,10 @@ withClientTransaction = PG.withClientTransaction runExceptT
 pgEqual :: forall a. Eq a => Show a => a -> a -> AppM Unit
 pgEqual a b = lift $ equal a b
 
-withRollback ∷
+withRollback
-  Client →
+  ∷ Client
-  AppM Unit →
+  → AppM Unit
-  AppM Unit
+  → AppM Unit
 withRollback client action = begin *> action *> rollback
   where
   conn = fromClient client
@@ -66,19 +66,19 @@ withRollback client action = begin *> action *> rollback
 
   rollback = execute conn (Query "ROLLBACK TRANSACTION") Row0
 
-test ∷
+test
-  Connection →
+  ∷ Connection
-  String →
+  → String
-  AppM Unit →
+  → AppM Unit
-  TestSuite
+  → TestSuite
 test (Connection (Left _)) name action = Test.Unit.test name $ checkPGErrors $ action
 
 test (Connection (Right client)) name action = Test.Unit.test name $ checkPGErrors $ withRollback client action
 
-transactionTest ∷
+transactionTest
-  String →
+  ∷ String
-  AppM Unit →
+  → AppM Unit
-  TestSuite
+  → TestSuite
 transactionTest name action = Test.Unit.test name $ checkPGErrors $ action
 
 checkPGErrors :: AppM Unit -> Aff Unit
@@ -487,8 +487,8 @@ main = do
                             equal (parseURI validUriToPoolConfigs.uri) (Just validUriToPoolConfigs.poolConfig)
                             equal (parseURI notValidConnUri) Nothing
 
-validUriToPoolConfigs ::
+validUriToPoolConfigs
-  { uri :: PGConnectionURI
+  :: { uri :: PGConnectionURI
      , poolConfig :: Configuration
      }
 validUriToPoolConfigs =