@uniflowed/sql 0.34.0 → 0.36.0

package/mysql.js

@@ -34,8 +34,8 @@ export type MysqlParam = null | string | Uint8Array;
 /** How one MySQL type becomes a Flow value and back. */
 export type Codec<T> = {|
   readonly sqlType: string,
-  readonly decode: (value: mixed) => T,
-  readonly encode: (value: T) => MysqlParam,
+  readonly decode : (value: mixed) => T,
+  readonly encode : (value: T) => MysqlParam,
 |};
 
 /** `TINYINT` through `INT`, signed or unsigned, and `YEAR`: all fit a `number`. */
@@ -55,7 +55,7 @@ export function integer(sqlType: string): Codec<number> {
 /** `BIGINT`, signed or unsigned, exactly. */
 export const bigint: Codec<bigint> = {
   sqlType: "bigint",
-  decode: (value) => bigintFrom("bigint", value),
+  decode : (value) => bigintFrom("bigint", value),
   encode: (value) => {
     if (typeof value !== "bigint") {
       return encodeError("bigint (a bigint)", value);
@@ -169,14 +169,14 @@ export function bytes(sqlType: string): Codec<Uint8Array> {
 /** `JSON`. */
 export const json: Codec<JsonValue> = {
   sqlType: "json",
-  decode: (value) => jsonFromText(value),
-  encode: (value) => jsonParam(value),
+  decode : (value) => jsonFromText(value),
+  encode : (value) => jsonParam(value),
 };
 
 /** A result sqlc could not type. */
 export const unknown: Codec<mixed> = {
   sqlType: "unknown",
-  decode: (value) => value,
+  decode : (value) => value,
   encode: (value) => {
     if (value === null || typeof value === "string" || value instanceof Uint8Array) {
       return value;
@@ -194,7 +194,7 @@ export const unknown: Codec<mixed> = {
 /** An `ENUM(…)` column, from its values in declaration order. */
 export function enumeration<T extends string>(
   sqlType: string,
-  values: $ReadOnlyArray<T>,
+  values : $ReadOnlyArray<T>,
 ): Codec<T> {
   const expected = `${sqlType} (${enumName(values)})`;
   return {
@@ -209,14 +209,14 @@ export function enumeration<T extends string>(
  * value back to what `codec` writes.
  */
 export function map<T, U>(
-  codec: Codec<T>,
+  codec : Codec<T>,
   decode: (value: T) => U,
   encode: (value: U) => T,
 ): Codec<U> {
   return {
     sqlType: codec.sqlType,
-    decode: (value) => decode(codec.decode(value)),
-    encode: (value) => codec.encode(encode(value)),
+    decode : (value) => decode(codec.decode(value)),
+    encode : (value) => codec.encode(encode(value)),
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uniflowed/sql",
-  "version": "0.34.0",
+  "version": "0.36.0",
   "description": "The runtime for sqlc's Flow target: exact codecs and driver adapters, part of the Unified Toolchain for Flow.",
   "type": "module",
   "license": "MIT",

package/postgresql.js

@@ -39,8 +39,8 @@ export type ArrayNode = string | null | $ReadOnlyArray<ArrayNode>;
 export type Codec<T> = {|
   /** For messages: `int8`, `text[]`. */
   readonly sqlType: string,
-  readonly decode: (value: mixed) => T,
-  readonly encode: (value: T) => string,
+  readonly decode : (value: mixed) => T,
+  readonly encode : (value: T) => string,
   readonly element: (node: ArrayNode) => T,
   /** The value as it appears inside `{…}`: quoted, or a nested literal. */
   readonly literal: (value: T) => string,
@@ -54,9 +54,9 @@ function quote(text: string): string {
 
 /** A scalar codec from its two text conversions. */
 export function scalar<T>(
-  sqlType: string,
+  sqlType : string,
   fromText: (text: string) => T,
-  toText: (value: T) => string,
+  toText  : (value: T) => string,
 ): Codec<T> {
   const decode = (value: mixed): T => {
     if (typeof value !== "string") {
@@ -78,7 +78,7 @@ export function scalar<T>(
       return fromText(node);
     },
     literal: (value) => quote(toText(value)),
-    depth: 0,
+    depth  : 0,
   };
 }
 
@@ -381,7 +381,7 @@ export const timestamptz: Codec<Date> = scalar("timestamptz", instantFromText, i
 /** A value sqlc could not type (`any`, `anyelement`, …): whatever the server printed. */
 export const unknown: Codec<mixed> = {
   sqlType: "unknown",
-  decode: (value) => value,
+  decode : (value) => value,
   encode: (value) => {
     if (typeof value === "string") {
       return value;
@@ -396,7 +396,7 @@ export const unknown: Codec<mixed> = {
   },
   element: (node) => node,
   literal: (value) => (value === null ? "NULL" : quote(String(value))),
-  depth: 0,
+  depth  : 0,
 };
 
 // ---------------------------------------------------------------------------
@@ -405,7 +405,7 @@ export const unknown: Codec<mixed> = {
 /** A codec for a `CREATE TYPE … AS ENUM`, from its labels in declaration order. */
 export function enumeration<T extends string>(
   sqlType: string,
-  values: $ReadOnlyArray<T>,
+  values : $ReadOnlyArray<T>,
 ): Codec<T> {
   const expected = `${sqlType} (${enumName(values)})`;
   return scalar(
@@ -550,10 +550,10 @@ export function array<T>(element: Codec<T>): Codec<$ReadOnlyArray<T>> {
       // An empty array has no dimensions at all, whatever the column says.
       return root.length === 0 ? [] : fromNode(root);
     },
-    encode: toLiteral,
+    encode : toLiteral,
     element: (node) => (Array.isArray(node) && node.length === 0 ? [] : fromNode(node)),
     literal: toLiteral,
-    depth: element.depth + 1,
+    depth  : element.depth + 1,
   };
 }
 
@@ -563,17 +563,17 @@ export function array<T>(element: Codec<T>): Codec<$ReadOnlyArray<T>> {
  * options, where `decode` is the application's own check.
  */
 export function map<T, U>(
-  codec: Codec<T>,
+  codec : Codec<T>,
   decode: (value: T) => U,
   encode: (value: U) => T,
 ): Codec<U> {
   return {
     sqlType: codec.sqlType,
-    decode: (value) => decode(codec.decode(value)),
-    encode: (value) => codec.encode(encode(value)),
+    decode : (value) => decode(codec.decode(value)),
+    encode : (value) => codec.encode(encode(value)),
     element: (node) => decode(codec.element(node)),
     literal: (value) => codec.literal(encode(value)),
-    depth: codec.depth,
+    depth  : codec.depth,
   };
 }
 

package/sqlite.js

@@ -31,8 +31,8 @@ import {
 /** How one declared type becomes a Flow value and back. */
 export type Codec<T> = {|
   readonly sqlType: string,
-  readonly decode: (value: mixed) => T,
-  readonly encode: (value: T) => SqlParam,
+  readonly decode : (value: mixed) => T,
+  readonly encode : (value: T) => SqlParam,
 |};
 
 /** `INTEGER` as a `number`, which throws past 2^53 instead of rounding. */
@@ -50,8 +50,8 @@ export const integer: Codec<number> = {
 /** `INTEGER` as a `bigint`, for `sqliteInteger: "bigint"`. */
 export const integerAsBigint: Codec<bigint> = {
   sqlType: "INTEGER",
-  decode: (value) => bigintFrom("INTEGER", value),
-  encode: (value) => bigintParam("INTEGER (a bigint)", value),
+  decode : (value) => bigintFrom("INTEGER", value),
+  encode : (value) => bigintParam("INTEGER (a bigint)", value),
 };
 
 /** `REAL`, `DOUBLE`, `FLOAT`, and `NUMERIC`/`DECIMAL`, which SQLite stores as one or an INTEGER. */
@@ -106,21 +106,21 @@ export const string: Codec<string> = text("TEXT");
 /** `BLOB`. */
 export const blob: Codec<Uint8Array> = {
   sqlType: "BLOB",
-  decode: (value) => bytesFrom("BLOB", value),
-  encode: (value) => bytesParam("BLOB (a Uint8Array)", value),
+  decode : (value) => bytesFrom("BLOB", value),
+  encode : (value) => bytesParam("BLOB (a Uint8Array)", value),
 };
 
 /** `JSON` and `JSONB` (sqlc reads the latter through `json()`), stored as text. */
 export const json: Codec<JsonValue> = {
   sqlType: "JSON",
-  decode: (value) => jsonFromText(value),
-  encode: (value) => jsonParam(value),
+  decode : (value) => jsonFromText(value),
+  encode : (value) => jsonParam(value),
 };
 
 /** A declared type with no affinity uf can type, or a result sqlc could not. */
 export const unknown: Codec<mixed> = {
   sqlType: "unknown",
-  decode: (value) => value,
+  decode : (value) => value,
   encode: (value) => {
     if (
       value === null ||
@@ -141,7 +141,7 @@ export const unknown: Codec<mixed> = {
 /** A `CHECK (x IN (…))`-style enum sqlc was told about through an override. */
 export function enumeration<T extends string>(
   sqlType: string,
-  values: $ReadOnlyArray<T>,
+  values : $ReadOnlyArray<T>,
 ): Codec<T> {
   const expected = `${sqlType} (${enumName(values)})`;
   return {
@@ -156,14 +156,14 @@ export function enumeration<T extends string>(
  * value back to what `codec` writes.
  */
 export function map<T, U>(
-  codec: Codec<T>,
+  codec : Codec<T>,
   decode: (value: T) => U,
   encode: (value: U) => T,
 ): Codec<U> {
   return {
     sqlType: codec.sqlType,
-    decode: (value) => decode(codec.decode(value)),
-    encode: (value) => codec.encode(encode(value)),
+    decode : (value) => decode(codec.decode(value)),
+    encode : (value) => codec.encode(encode(value)),
   };
 }