addressing review comments, cleaning up text search casing

Author: ymc9

packages/common-helpers/src/index.ts

@@ -1,7 +1,6 @@
 export * from './is-plain-object';
 export * from './lower-case-first';
 export * from './param-case';
-export * from './promise-utils';
 export * from './sleep';
 export * from './tiny-invariant';
 export * from './upper-case-first';

packages/common-helpers/src/promise-utils.ts

@@ -123,8 +123,10 @@ function future(): Any {
 } @@@expressionContext([AccessPolicy])
 
 /**
- * If the field value contains the search string. By default, the search is case-sensitive,
- * but you can override the behavior with the "caseInSensitive" argument.
+ * Checks if the field value contains the search string. By default, the search is case-sensitive, and
+ * "LIKE" operator is used to match. If `caseInSensitive` is true, "ILIKE" operator is used if
+ * supported, otherwise it still falls back to "LIKE" and delivers whatever the database's 
+ * behavior is.
  */
 function contains(field: String, search: String, caseInSensitive: Boolean?): Boolean {
 } @@@expressionContext([AccessPolicy, ValidationRule])
@@ -136,15 +138,21 @@ function search(field: String, search: String): Boolean {
 } @@@expressionContext([AccessPolicy])
 
 /**
- * If the field value starts with the search string
+ * Checks the field value starts with the search string. By default, the search is case-sensitive, and
+ * "LIKE" operator is used to match. If `caseInSensitive` is true, "ILIKE" operator is used if
+ * supported, otherwise it still falls back to "LIKE" and delivers whatever the database's 
+ * behavior is.
  */
-function startsWith(field: String, search: String): Boolean {
+function startsWith(field: String, search: String, caseInSensitive: Boolean?): Boolean {
 } @@@expressionContext([AccessPolicy, ValidationRule])
 
 /**
- * If the field value ends with the search string
+ * Checks if the field value ends with the search string. By default, the search is case-sensitive, and
+ * "LIKE" operator is used to match. If `caseInSensitive` is true, "ILIKE" operator is used if
+ * supported, otherwise it still falls back to "LIKE" and delivers whatever the database's 
+ * behavior is.
  */
-function endsWith(field: String, search: String): Boolean {
+function endsWith(field: String, search: String, caseInSensitive: Boolean?): Boolean {
 } @@@expressionContext([AccessPolicy, ValidationRule])
 
 /**

packages/language/res/stdlib.zmodel

@@ -1264,5 +1264,10 @@ export abstract class BaseCrudDialect<Schema extends SchemaDef> {
      */
     abstract getFieldSqlType(fieldDef: FieldDef): string;
 
+    /*
+     * Gets the string casing behavior for the dialect.
+     */
+    abstract getStringCasingBehavior(): { supportsILike: boolean; likeCaseSensitive: boolean };
+
     // #endregion
 }

packages/runtime/src/client/crud/dialects/base-dialect.ts

@@ -63,6 +63,9 @@ export class PostgresCrudDialect<Schema extends SchemaDef> extends BaseCrudDiale
     }
 
     override transformOutput(value: unknown, type: BuiltinType) {
+        if (value === null || value === undefined) {
+            return value;
+        }
         return match(type)
             .with('DateTime', () => this.transformOutputDate(value))
             .with('Bytes', () => this.transformOutputBytes(value))
@@ -96,9 +99,12 @@ export class PostgresCrudDialect<Schema extends SchemaDef> extends BaseCrudDiale
     private transformOutputDate(value: unknown) {
         if (typeof value === 'string') {
             return new Date(value);
-        } else if (value instanceof Date) {
-            value.setTime(value.getTime() - value.getTimezoneOffset() * 60 * 1000);
-            return value;
+        } else if (value instanceof Date && this.options.fixPostgresTimezone !== false) {
+            // SPECIAL NOTES:
+            // node-pg has a terrible quirk that it returns the date value in local timezone
+            // as a `Date` object although for `DateTime` field the data in DB is stored in UTC
+            // see: https://github.com/brianc/node-postgres/issues/429
+            return new Date(value.getTime() - value.getTimezoneOffset() * 60 * 1000);
         } else {
             return value;
         }
@@ -460,4 +466,9 @@ export class PostgresCrudDialect<Schema extends SchemaDef> extends BaseCrudDiale
 
         return result;
     }
+
+    override getStringCasingBehavior() {
+        // Postgres `LIKE` is case-sensitive, `ILIKE` is case-insensitive
+        return { supportsILike: true, likeCaseSensitive: true };
+    }
 }

packages/runtime/src/client/crud/dialects/postgresql.ts

@@ -58,7 +58,9 @@ export class SqliteCrudDialect<Schema extends SchemaDef> extends BaseCrudDialect
     }
 
     override transformOutput(value: unknown, type: BuiltinType) {
-        if (this.schema.typeDefs && type in this.schema.typeDefs) {
+        if (value === null || value === undefined) {
+            return value;
+        } else if (this.schema.typeDefs && type in this.schema.typeDefs) {
             // typed JSON field
             return this.transformOutputJson(value);
         } else {
@@ -114,9 +116,15 @@ export class SqliteCrudDialect<Schema extends SchemaDef> extends BaseCrudDialect
     }
 
     private transformOutputJson(value: unknown) {
-        // better-sqlite3 returns JSON as string
-        invariant(typeof value === 'string', 'Expected string, got ' + typeof value);
-        return JSON.parse(value as string);
+        // better-sqlite3 typically returns JSON as string; be tolerant
+        if (typeof value === 'string') {
+            try {
+                return JSON.parse(value);
+            } catch (e) {
+                throw new QueryError('Invalid JSON returned', e);
+            }
+        }
+        return value;
     }
 
     override buildRelationSelection(
@@ -400,4 +408,9 @@ export class SqliteCrudDialect<Schema extends SchemaDef> extends BaseCrudDialect
                 .otherwise(() => 'text')
         );
     }
+
+    override getStringCasingBehavior() {
+        // SQLite `LIKE` is case-insensitive, and there is no `ILIKE`
+        return { supportsILike: false, likeCaseSensitive: false };
+    }
 }

packages/runtime/src/client/crud/dialects/sqlite.ts

@@ -1,48 +1,65 @@
 import { invariant, lowerCaseFirst, upperCaseFirst } from '@zenstackhq/common-helpers';
-import { sql, ValueNode, type Expression, type ExpressionBuilder } from 'kysely';
+import { sql, ValueNode, type BinaryOperator, type Expression, type ExpressionBuilder } from 'kysely';
 import { match } from 'ts-pattern';
 import type { ZModelFunction, ZModelFunctionContext } from './options';
 
 // TODO: migrate default value generation functions to here too
 
-export const contains: ZModelFunction<any> = (eb, args) => {
-    const [field, search, caseInsensitive = false] = args;
-    if (!field) {
-        throw new Error('"field" parameter is required');
-    }
-    if (!search) {
-        throw new Error('"search" parameter is required');
-    }
-    const searchExpr = eb.fn('CONCAT', [sql.lit('%'), sql`CAST(${search} as text)`, sql.lit('%')]);
-    return eb(field, caseInsensitive ? 'ilike' : 'like', searchExpr);
-};
+export const contains: ZModelFunction<any> = (eb, args, context) => textMatch(eb, args, context, 'contains');
 
 export const search: ZModelFunction<any> = (_eb: ExpressionBuilder<any, any>, _args: Expression<any>[]) => {
     throw new Error(`"search" function is not implemented yet`);
 };
 
-export const startsWith: ZModelFunction<any> = (eb, args) => {
-    const [field, search] = args;
+export const startsWith: ZModelFunction<any> = (eb, args, context) => textMatch(eb, args, context, 'startsWith');
+
+export const endsWith: ZModelFunction<any> = (eb, args, context) => textMatch(eb, args, context, 'endsWith');
+
+const textMatch = (
+    eb: ExpressionBuilder<any, any>,
+    args: Expression<any>[],
+    { dialect }: ZModelFunctionContext<any>,
+    method: 'contains' | 'startsWith' | 'endsWith',
+) => {
+    const [field, search, caseInsensitive = undefined] = args;
     if (!field) {
         throw new Error('"field" parameter is required');
     }
     if (!search) {
         throw new Error('"search" parameter is required');
     }
-    const searchExpr = eb.fn('CONCAT', [sql`CAST(${search} as text)`, sql.lit('%')]);
-    return eb(field, 'like', searchExpr);
-};
 
-export const endsWith: ZModelFunction<any> = (eb, args) => {
-    const [field, search] = args;
-    if (!field) {
-        throw new Error('"field" parameter is required');
-    }
-    if (!search) {
-        throw new Error('"search" parameter is required');
+    const casingBehavior = dialect.getStringCasingBehavior();
+    const caseInsensitiveValue = readBoolean(caseInsensitive, false);
+    let op: BinaryOperator;
+    let fieldExpr = field;
+    let searchExpr = search;
+
+    if (caseInsensitiveValue) {
+        // case-insensitive search
+        if (casingBehavior.supportsILike) {
+            // use ILIKE if supported
+            op = 'ilike';
+        } else {
+            // otherwise change both sides to lower case
+            op = 'like';
+            if (casingBehavior.likeCaseSensitive === true) {
+                fieldExpr = eb.fn('LOWER', [fieldExpr]);
+                searchExpr = eb.fn('LOWER', [searchExpr]);
+            }
+        }
+    } else {
+        // case-sensitive search, just use LIKE and deliver whatever the database's behavior is
+        op = 'like';
     }
-    const searchExpr = eb.fn('CONCAT', [sql.lit('%'), sql`CAST(${search} as text)`]);
-    return eb(field, 'like', searchExpr);
+
+    searchExpr = match(method)
+        .with('contains', () => eb.fn('CONCAT', [sql.lit('%'), sql`CAST(${searchExpr} as text)`, sql.lit('%')]))
+        .with('startsWith', () => eb.fn('CONCAT', [sql`CAST(${searchExpr} as text)`, sql.lit('%')]))
+        .with('endsWith', () => eb.fn('CONCAT', [sql.lit('%'), sql`CAST(${searchExpr} as text)`]))
+        .exhaustive();
+
+    return eb(fieldExpr, op, searchExpr);
 };
 
 export const has: ZModelFunction<any> = (eb, args) => {
@@ -122,3 +139,12 @@ function processCasing(casing: Expression<any>, result: string, model: string) {
         });
     return result;
 }
+
+function readBoolean(expr: Expression<any> | undefined, defaultValue: boolean) {
+    if (expr === undefined) {
+        return defaultValue;
+    }
+    const opNode = expr.toOperationNode();
+    invariant(ValueNode.is(opNode), 'expression must be a literal value');
+    return !!opNode.value;
+}

packages/runtime/src/client/functions.ts

@@ -62,6 +62,16 @@ export type ClientOptions<Schema extends SchemaDef> = {
      * Logging configuration.
      */
     log?: KyselyConfig['log'];
+
+    /**
+     * Whether to automatically fix timezone for `DateTime` fields returned by node-pg. Defaults
+     * to `true`.
+     *
+     * Node-pg has a terrible quirk that it interprets the date value as local timezone (as a
+     * `Date` object) although for `DateTime` field the data in DB is stored in UTC.
+     * @see https://github.com/brianc/node-postgres/issues/429
+     */
+    fixPostgresTimezone?: boolean;
 } & (HasComputedFields<Schema> extends true
     ? {
           /**