supabase-typed-query 0.12.0 → 1.0.0

package/dist/index.js

@@ -47,9 +47,6 @@ const log = {
   info: (msg) => process.env.NODE_ENV !== "test" && console.info(`[supabase-typed-query] ${msg}`)
 };
 const TABLES_WITHOUT_DELETED = /* @__PURE__ */ new Set([]);
-const wrapAsync$2 = (fn) => {
-  return fn();
-};
 const QueryBuilder = (client, config) => {
   const buildSupabaseQuery = () => {
     const { table, conditions, order, limit, offset, schema } = config;
@@ -69,7 +66,7 @@ const QueryBuilder = (client, config) => {
     return finalQuery;
   };
   const applyCondition = (query2, condition) => {
-    const { where, is, wherein, gt, gte, lt, lte, neq, like, ilike } = condition;
+    const { where, is, wherein, gt, gte, lt, lte, neq, like, ilike, not } = condition;
     const processedWhere = {};
     const extractedOperators = {};
     if (where) {
@@ -183,10 +180,18 @@ const QueryBuilder = (client, config) => {
     const queryWithGte = Object.keys(mergedGte).length > 0 ? Object.entries(mergedGte).reduce((q, [key, value]) => q.gte(key, value), queryWithGt) : queryWithGt;
     const queryWithLt = Object.keys(mergedLt).length > 0 ? Object.entries(mergedLt).reduce((q, [key, value]) => q.lt(key, value), queryWithGte) : queryWithGte;
     const queryWithLte = Object.keys(mergedLte).length > 0 ? Object.entries(mergedLte).reduce((q, [key, value]) => q.lte(key, value), queryWithLt) : queryWithLt;
-    const queryWithNeq = Object.keys(mergedNeq).length > 0 ? Object.entries(mergedNeq).reduce((q, [key, value]) => q.neq(key, value), queryWithLte) : queryWithLte;
+    const queryWithNeq = Object.keys(mergedNeq).length > 0 ? Object.entries(mergedNeq).reduce((q, [key, value]) => {
+      if (value === null) {
+        log.warn(`neq: null is deprecated. Use not: { is: { ${key}: null } } for IS NOT NULL`);
+        return q.not(key, "is", null);
+      }
+      return q.neq(key, value);
+    }, queryWithLte) : queryWithLte;
     const queryWithLike = Object.keys(mergedLike).length > 0 ? Object.entries(mergedLike).reduce((q, [key, pattern]) => q.like(key, pattern), queryWithNeq) : queryWithNeq;
     const queryWithIlike = Object.keys(mergedIlike).length > 0 ? Object.entries(mergedIlike).reduce((q, [key, pattern]) => q.ilike(key, pattern), queryWithLike) : queryWithLike;
-    return queryWithIlike;
+    const queryWithNotIs = not?.is ? Object.entries(not.is).reduce((q, [key, value]) => q.not(key, "is", value), queryWithIlike) : queryWithIlike;
+    const queryWithNot = not?.in ? Object.entries(not.in).reduce((q, [key, values]) => q.not(key, "in", values), queryWithNotIs) : queryWithNotIs;
+    return queryWithNot;
   };
   const applyOrConditions = (query2, conditions) => {
     const selectQuery = query2.select("*");
@@ -223,7 +228,8 @@ const QueryBuilder = (client, config) => {
           return {
             where: newWhere,
             is: condition.is,
-            wherein: condition.wherein
+            wherein: condition.wherein,
+            not: condition.not
           };
         })
       );
@@ -287,6 +293,7 @@ const QueryBuilder = (client, config) => {
       if (condition.neq) {
         Object.entries(condition.neq).forEach(([key, value]) => {
           if (value === null) {
+            log.warn(`neq: null is deprecated. Use not: { is: { ${key}: null } } for IS NOT NULL`);
             parts.push(`${key}.not.is.null`);
           } else {
             parts.push(`${key}.neq."${value}"`);
@@ -303,6 +310,25 @@ const QueryBuilder = (client, config) => {
           parts.push(`${key}.ilike."${pattern}"`);
         });
       }
+      if (condition.not) {
+        if (condition.not.is) {
+          Object.entries(condition.not.is).forEach(([key, value]) => {
+            if (value === null) {
+              parts.push(`${key}.not.is.null`);
+            } else {
+              parts.push(`${key}.not.is.${value}`);
+            }
+          });
+        }
+        if (condition.not.in) {
+          Object.entries(condition.not.in).forEach(([key, values]) => {
+            if (values && Array.isArray(values) && values.length > 0) {
+              const valueList = values.map((v) => `"${v}"`).join(",");
+              parts.push(`${key}.not.in.(${valueList})`);
+            }
+          });
+        }
+      }
       return parts.join(",");
     }).filter((condition) => condition.length > 0);
     const finalQuery = orConditions.length > 0 ? queryWithCommon.or(orConditions.join(",")) : queryWithCommon;
@@ -415,81 +441,52 @@ const QueryBuilder = (client, config) => {
      * Execute query expecting exactly one result
      */
     one: () => {
-      return wrapAsync$2(async () => {
-        try {
-          const query2 = buildSupabaseQuery();
-          const { data, error } = await query2.single();
-          if (error) {
-            log.error(`Error getting ${config.table} item: ${toError(error).toString()}`);
-            return functype.Err(toError(error));
-          }
-          const result = data;
-          const filteredResult = config.filterFn ? config.filterFn(result) : true;
-          if (!filteredResult) {
-            return functype.Ok(functype.Option.none());
-          }
-          return functype.Ok(functype.Option(result));
-        } catch (error) {
-          log.error(`Error executing single query on ${config.table}: ${toError(error).toString()}`);
-          return functype.Err(toError(error));
-        }
-      });
+      return functype.IO.tryAsync(async () => {
+        const query2 = buildSupabaseQuery();
+        const { data, error } = await query2.single();
+        if (error) throw toError(error);
+        const result = data;
+        const passes = config.filterFn ? config.filterFn(result) : true;
+        return passes ? functype.Option(result) : functype.Option.none();
+      }, toError).tapError((err) => log.error(`Error getting ${config.table} item: ${err}`));
     },
     /**
      * Execute query expecting zero or more results
      */
     many: () => {
-      return wrapAsync$2(async () => {
-        try {
-          const query2 = buildSupabaseQuery();
-          const { data, error } = await query2;
-          if (error) {
-            log.error(`Error getting ${config.table} items: ${toError(error).toString()}`);
-            return functype.Err(toError(error));
-          }
-          const rawResults = data;
-          const results = config.filterFn ? rawResults.filter(config.filterFn) : rawResults;
-          return functype.Ok(functype.List(results));
-        } catch (error) {
-          log.error(`Error executing multi query on ${config.table}: ${toError(error).toString()}`);
-          return functype.Err(toError(error));
-        }
-      });
+      return functype.IO.tryAsync(async () => {
+        const query2 = buildSupabaseQuery();
+        const { data, error } = await query2;
+        if (error) throw toError(error);
+        const rawResults = data;
+        const results = config.filterFn ? rawResults.filter(config.filterFn) : rawResults;
+        return functype.List(results);
+      }, toError).tapError((err) => log.error(`Error getting ${config.table} items: ${err}`));
     },
     /**
      * Execute query expecting first result from potentially multiple
      */
     first: () => {
-      return wrapAsync$2(async () => {
-        const manyResult = await QueryBuilder(client, config).many();
-        const list = manyResult.orThrow();
-        if (list.isEmpty) {
-          return functype.Ok(functype.Option.none());
-        }
-        return functype.Ok(functype.Option(list.head));
-      });
+      return QueryBuilder(client, config).many().map((list) => list.isEmpty ? functype.Option.none() : functype.Option(list.head));
     },
     /**
      * Execute query expecting exactly one result, throw if error or not found
      */
     oneOrThrow: async () => {
-      const result = await QueryBuilder(client, config).one();
-      const option = result.orThrow();
+      const option = await QueryBuilder(client, config).one().runOrThrow();
       return option.orThrow(new Error(`No record found in ${config.table}`));
     },
     /**
      * Execute query expecting zero or more results, throw if error
      */
     manyOrThrow: async () => {
-      const result = await QueryBuilder(client, config).many();
-      return result.orThrow();
+      return QueryBuilder(client, config).many().runOrThrow();
     },
     /**
      * Execute query expecting first result, throw if error or empty
      */
     firstOrThrow: async () => {
-      const result = await QueryBuilder(client, config).first();
-      const option = result.orThrow();
+      const option = await QueryBuilder(client, config).first().runOrThrow();
       return option.orThrow(new Error(`No records found in ${config.table}`));
     }
   };
@@ -504,61 +501,50 @@ const createMappedQuery = (sourceQuery, mapFn) => {
       return createMappedQuery(filteredQuery, mapFn);
     },
     one: () => {
-      return wrapAsync$2(async () => {
-        const maybeItemResult = await sourceQuery.one();
-        const maybeItem = maybeItemResult.orThrow();
-        return maybeItem.fold(
-          () => functype.Ok(functype.Option.none()),
-          (item) => functype.Ok(functype.Option(mapFn(item)))
-        );
-      });
+      return sourceQuery.one().map(
+        (maybeItem) => maybeItem.fold(
+          () => functype.Option.none(),
+          (item) => functype.Option(mapFn(item))
+        )
+      );
     },
     many: () => {
-      return wrapAsync$2(async () => {
-        const itemsResult = await sourceQuery.many();
-        const items = itemsResult.orThrow();
-        return functype.Ok(items.map(mapFn));
-      });
+      return sourceQuery.many().map((items) => items.map(mapFn));
     },
     first: () => {
-      return wrapAsync$2(async () => {
-        const maybeItemResult = await sourceQuery.first();
-        const maybeItem = maybeItemResult.orThrow();
-        return maybeItem.fold(
-          () => functype.Ok(functype.Option.none()),
-          (item) => functype.Ok(functype.Option(mapFn(item)))
-        );
-      });
+      return sourceQuery.first().map(
+        (maybeItem) => maybeItem.fold(
+          () => functype.Option.none(),
+          (item) => functype.Option(mapFn(item))
+        )
+      );
     },
     /**
      * Execute mapped query expecting exactly one result, throw if error or not found
      */
     oneOrThrow: async () => {
-      const result = await createMappedQuery(sourceQuery, mapFn).one();
-      const option = result.orThrow();
+      const option = await createMappedQuery(sourceQuery, mapFn).one().runOrThrow();
       return option.orThrow(new Error(`No record found`));
     },
     /**
      * Execute mapped query expecting zero or more results, throw if error
      */
     manyOrThrow: async () => {
-      const result = await createMappedQuery(sourceQuery, mapFn).many();
-      return result.orThrow();
+      return createMappedQuery(sourceQuery, mapFn).many().runOrThrow();
     },
     /**
      * Execute mapped query expecting first result, throw if error or empty
      */
     firstOrThrow: async () => {
-      const result = await createMappedQuery(sourceQuery, mapFn).first();
-      const option = result.orThrow();
+      const option = await createMappedQuery(sourceQuery, mapFn).first().runOrThrow();
       return option.orThrow(new Error(`No records found`));
     }
   };
 };
-const createQuery = (client, table, where = {}, is, wherein, order, softDeleteConfig, schema, comparison) => {
+const createQuery = (client, table, where = {}, is, wherein, order, softDeleteConfig, schema, comparison, not) => {
   const config = {
     table,
-    conditions: [{ where, is, wherein, ...comparison }],
+    conditions: [{ where, is, wherein, ...comparison, not }],
     order,
     softDeleteMode: softDeleteConfig?.mode,
     softDeleteAppliedByDefault: softDeleteConfig?.appliedByDefault,
@@ -572,38 +558,28 @@ const isQuery = (obj) => {
 const isMappedQuery = (obj) => {
   return typeof obj === "object" && obj !== null && "one" in obj && "many" in obj && "first" in obj && "map" in obj && "filter" in obj;
 };
-const wrapAsync$1 = (fn) => {
-  return fn();
-};
 const rpc = (client, functionName, args, options) => {
   const executeRpc = () => {
     return client.rpc(functionName, args ?? {}, {
       count: options?.count
     });
   };
-  const one = () => wrapAsync$1(async () => {
-    try {
-      const { data, error } = await executeRpc();
-      if (error) {
-        return functype.Err(toError(error));
-      }
-      if (data === null || data === void 0) {
-        return functype.Ok(functype.Option.none());
-      }
-      if (Array.isArray(data)) {
-        if (data.length === 0) {
-          return functype.Ok(functype.Option.none());
-        }
-        return functype.Ok(functype.Option(data[0]));
+  const one = () => functype.IO.tryAsync(async () => {
+    const { data, error } = await executeRpc();
+    if (error) throw toError(error);
+    if (data === null || data === void 0) {
+      return functype.Option.none();
+    }
+    if (Array.isArray(data)) {
+      if (data.length === 0) {
+        return functype.Option.none();
       }
-      return functype.Ok(functype.Option(data));
-    } catch (error) {
-      return functype.Err(toError(error));
+      return functype.Option(data[0]);
     }
-  });
+    return functype.Option(data);
+  }, toError);
   const oneOrThrow = async () => {
-    const result = await one();
-    const option = result.orThrow();
+    const option = await one().runOrThrow();
     return option.fold(
       () => {
         throw new Error("RPC call returned no result");
@@ -611,26 +587,19 @@ const rpc = (client, functionName, args, options) => {
       (value) => value
     );
   };
-  const many = () => wrapAsync$1(async () => {
-    try {
-      const { data, error } = await executeRpc();
-      if (error) {
-        return functype.Err(toError(error));
-      }
-      if (data === null || data === void 0) {
-        return functype.Ok(functype.List([]));
-      }
-      if (Array.isArray(data)) {
-        return functype.Ok(functype.List(data));
-      }
-      return functype.Ok(functype.List([data]));
-    } catch (error) {
-      return functype.Err(toError(error));
+  const many = () => functype.IO.tryAsync(async () => {
+    const { data, error } = await executeRpc();
+    if (error) throw toError(error);
+    if (data === null || data === void 0) {
+      return functype.List([]);
+    }
+    if (Array.isArray(data)) {
+      return functype.List(data);
     }
-  });
+    return functype.List([data]);
+  }, toError);
   const manyOrThrow = async () => {
-    const result = await many();
-    return result.orThrow();
+    return many().runOrThrow();
   };
   return {
     one,
@@ -639,208 +608,145 @@ const rpc = (client, functionName, args, options) => {
     manyOrThrow
   };
 };
-const wrapAsync = (fn) => {
-  return fn();
-};
-const getEntity = (client, table, where, is, schema) => wrapAsync(async () => {
-  try {
-    const tableQuery = schema ? client.schema(schema).from(table) : client.from(table);
-    const baseQuery = tableQuery.select("*").match(where);
-    const queryWithIs = is ? functype.List(Object.entries(is)).foldLeft(baseQuery)(
-      (query2, [column, value]) => query2.is(column, value)
-    ) : baseQuery;
-    const { data, error } = await queryWithIs.single();
-    if (error) {
-      return functype.Err(toError(error));
-    }
-    return functype.Ok(data);
-  } catch (error) {
-    return functype.Err(toError(error));
-  }
-});
+const getEntity = (client, table, where, is, schema) => functype.IO.tryAsync(async () => {
+  const tableQuery = schema ? client.schema(schema).from(table) : client.from(table);
+  const baseQuery = tableQuery.select("*").match(where);
+  const queryWithIs = is ? functype.List(Object.entries(is)).foldLeft(baseQuery)(
+    (query2, [column, value]) => query2.is(column, value)
+  ) : baseQuery;
+  const { data, error } = await queryWithIs.single();
+  if (error) throw toError(error);
+  return data;
+}, toError);
 const getEntities = (client, table, where = {}, is, wherein, order = [
   "id",
   { ascending: true }
-], schema) => wrapAsync(async () => {
-  try {
-    const tableQuery = schema ? client.schema(schema).from(table) : client.from(table);
-    const baseQuery = tableQuery.select("*").match(where);
-    const queryWithIn = wherein ? functype.List(Object.entries(wherein)).foldLeft(baseQuery)(
-      (query2, [column, values]) => query2.in(column, values)
-    ) : baseQuery;
-    const queryWithIs = is ? functype.List(Object.entries(is)).foldLeft(queryWithIn)(
-      (query2, [column, value]) => query2.is(column, value)
-    ) : queryWithIn;
-    const queryOrderBy = queryWithIs.order(order[0], order[1]);
-    const { data, error } = await queryOrderBy;
-    if (error) {
-      return functype.Err(toError(error));
-    }
-    return functype.Ok(functype.List(data));
-  } catch (error) {
-    return functype.Err(toError(error));
-  }
-});
-const addEntities = (client, table, entities, schema) => wrapAsync(async () => {
-  try {
-    const tableQuery = schema ? client.schema(schema).from(table) : client.from(table);
-    const { data, error } = await tableQuery.insert(entities).select();
-    if (error) {
-      return functype.Err(toError(error));
-    }
-    return functype.Ok(functype.List(data));
-  } catch (error) {
-    return functype.Err(toError(error));
-  }
-});
-const updateEntity = (client, table, entities, where, is, wherein, schema) => wrapAsync(async () => {
-  try {
-    const tableQuery = schema ? client.schema(schema).from(table) : client.from(table);
-    const baseQuery = tableQuery.update(entities).match(where);
-    const queryWithIn = wherein ? functype.List(Object.entries(wherein)).foldLeft(baseQuery)(
-      (query2, [column, values]) => query2.in(column, values)
-    ) : baseQuery;
-    const queryWithIs = is ? functype.List(Object.entries(is)).foldLeft(queryWithIn)(
-      (query2, [column, value]) => query2.is(column, value)
-    ) : queryWithIn;
-    const { data, error } = await queryWithIs.select().single();
-    if (error) {
-      return functype.Err(toError(error));
-    }
-    return functype.Ok(data);
-  } catch (error) {
-    return functype.Err(toError(error));
-  }
-});
-const upsertEntities = (client, table, entities, identity = "id", where, is, wherein, schema) => wrapAsync(async () => {
-  try {
-    const onConflict = Array.isArray(identity) ? identity.join(",") : identity;
-    const tableQuery = schema ? client.schema(schema).from(table) : client.from(table);
-    const baseQuery = tableQuery.upsert(entities, { onConflict }).match(where ?? {});
-    const queryWithIn = wherein ? functype.List(Object.entries(wherein)).foldLeft(baseQuery)(
-      (query2, [column, values]) => query2.in(column, values)
-    ) : baseQuery;
-    const queryWithIs = is ? functype.List(Object.entries(is)).foldLeft(queryWithIn)(
-      (query2, [column, value]) => query2.is(column, value)
-    ) : queryWithIn;
-    const { data, error } = await queryWithIs.select();
-    if (error) {
-      return functype.Err(toError(error));
-    }
-    return functype.Ok(functype.List(data));
-  } catch (error) {
-    return functype.Err(toError(error));
-  }
-});
-const deleteEntity = (client, table, where, is, wherein, schema) => wrapAsync(async () => {
-  try {
-    const tableQuery = schema ? client.schema(schema).from(table) : client.from(table);
-    const baseQuery = tableQuery.delete().match(where);
-    const queryWithIn = wherein ? functype.List(Object.entries(wherein)).foldLeft(baseQuery)(
-      (query2, [column, values]) => query2.in(column, values)
-    ) : baseQuery;
-    const queryWithIs = is ? functype.List(Object.entries(is)).foldLeft(queryWithIn)(
-      (query2, [column, value]) => query2.is(column, value)
-    ) : queryWithIn;
-    const { data, error } = await queryWithIs.select().single();
-    if (error) {
-      return functype.Err(toError(error));
-    }
-    return functype.Ok(data);
-  } catch (error) {
-    return functype.Err(toError(error));
-  }
-});
-const deleteEntities = (client, table, where, is, wherein, schema) => wrapAsync(async () => {
-  try {
-    const tableQuery = schema ? client.schema(schema).from(table) : client.from(table);
-    const baseQuery = tableQuery.delete().match(where);
-    const queryWithIn = wherein ? functype.List(Object.entries(wherein)).foldLeft(baseQuery)(
-      (query2, [column, values]) => query2.in(column, values)
-    ) : baseQuery;
-    const queryWithIs = is ? functype.List(Object.entries(is)).foldLeft(queryWithIn)(
-      (query2, [column, value]) => query2.is(column, value)
-    ) : queryWithIn;
-    const { data, error } = await queryWithIs.select();
-    if (error) {
-      return functype.Err(toError(error));
-    }
-    return functype.Ok(functype.List(data));
-  } catch (error) {
-    return functype.Err(toError(error));
-  }
-});
-const softDeleteEntity = (client, table, where, is, wherein, schema) => wrapAsync(async () => {
-  try {
-    const tableQuery = schema ? client.schema(schema).from(table) : client.from(table);
-    const baseQuery = tableQuery.update({ deleted: (/* @__PURE__ */ new Date()).toISOString() }).match(where);
-    const queryWithIn = wherein ? functype.List(Object.entries(wherein)).foldLeft(baseQuery)(
-      (query2, [column, values]) => query2.in(column, values)
-    ) : baseQuery;
-    const queryWithIs = is ? functype.List(Object.entries(is)).foldLeft(queryWithIn)(
-      (query2, [column, value]) => query2.is(column, value)
-    ) : queryWithIn;
-    const { data, error } = await queryWithIs.select().single();
-    if (error) {
-      return functype.Err(toError(error));
-    }
-    return functype.Ok(data);
-  } catch (error) {
-    return functype.Err(toError(error));
-  }
-});
-const softDeleteEntities = (client, table, where, is, wherein, schema) => wrapAsync(async () => {
-  try {
-    const tableQuery = schema ? client.schema(schema).from(table) : client.from(table);
-    const baseQuery = tableQuery.update({ deleted: (/* @__PURE__ */ new Date()).toISOString() }).match(where);
-    const queryWithIn = wherein ? functype.List(Object.entries(wherein)).foldLeft(baseQuery)(
-      (query2, [column, values]) => query2.in(column, values)
-    ) : baseQuery;
-    const queryWithIs = is ? functype.List(Object.entries(is)).foldLeft(queryWithIn)(
-      (query2, [column, value]) => query2.is(column, value)
-    ) : queryWithIn;
-    const { data, error } = await queryWithIs.select();
-    if (error) {
-      return functype.Err(toError(error));
-    }
-    return functype.Ok(functype.List(data));
-  } catch (error) {
-    return functype.Err(toError(error));
-  }
-});
+], schema) => functype.IO.tryAsync(async () => {
+  const tableQuery = schema ? client.schema(schema).from(table) : client.from(table);
+  const baseQuery = tableQuery.select("*").match(where);
+  const queryWithIn = wherein ? functype.List(Object.entries(wherein)).foldLeft(baseQuery)(
+    (query2, [column, values]) => query2.in(column, values)
+  ) : baseQuery;
+  const queryWithIs = is ? functype.List(Object.entries(is)).foldLeft(queryWithIn)(
+    (query2, [column, value]) => query2.is(column, value)
+  ) : queryWithIn;
+  const queryOrderBy = queryWithIs.order(order[0], order[1]);
+  const { data, error } = await queryOrderBy;
+  if (error) throw toError(error);
+  return functype.List(data);
+}, toError);
+const addEntities = (client, table, entities, schema) => functype.IO.tryAsync(async () => {
+  const tableQuery = schema ? client.schema(schema).from(table) : client.from(table);
+  const { data, error } = await tableQuery.insert(entities).select();
+  if (error) throw toError(error);
+  return functype.List(data);
+}, toError);
+const updateEntity = (client, table, entities, where, is, wherein, schema) => functype.IO.tryAsync(async () => {
+  const tableQuery = schema ? client.schema(schema).from(table) : client.from(table);
+  const baseQuery = tableQuery.update(entities).match(where);
+  const queryWithIn = wherein ? functype.List(Object.entries(wherein)).foldLeft(baseQuery)(
+    (query2, [column, values]) => query2.in(column, values)
+  ) : baseQuery;
+  const queryWithIs = is ? functype.List(Object.entries(is)).foldLeft(queryWithIn)(
+    (query2, [column, value]) => query2.is(column, value)
+  ) : queryWithIn;
+  const { data, error } = await queryWithIs.select().single();
+  if (error) throw toError(error);
+  return data;
+}, toError);
+const upsertEntities = (client, table, entities, identity = "id", where, is, wherein, schema) => functype.IO.tryAsync(async () => {
+  const onConflict = Array.isArray(identity) ? identity.join(",") : identity;
+  const tableQuery = schema ? client.schema(schema).from(table) : client.from(table);
+  const baseQuery = tableQuery.upsert(entities, { onConflict }).match(where ?? {});
+  const queryWithIn = wherein ? functype.List(Object.entries(wherein)).foldLeft(baseQuery)(
+    (query2, [column, values]) => query2.in(column, values)
+  ) : baseQuery;
+  const queryWithIs = is ? functype.List(Object.entries(is)).foldLeft(queryWithIn)(
+    (query2, [column, value]) => query2.is(column, value)
+  ) : queryWithIn;
+  const { data, error } = await queryWithIs.select();
+  if (error) throw toError(error);
+  return functype.List(data);
+}, toError);
+const deleteEntity = (client, table, where, is, wherein, schema) => functype.IO.tryAsync(async () => {
+  const tableQuery = schema ? client.schema(schema).from(table) : client.from(table);
+  const baseQuery = tableQuery.delete().match(where);
+  const queryWithIn = wherein ? functype.List(Object.entries(wherein)).foldLeft(baseQuery)(
+    (query2, [column, values]) => query2.in(column, values)
+  ) : baseQuery;
+  const queryWithIs = is ? functype.List(Object.entries(is)).foldLeft(queryWithIn)(
+    (query2, [column, value]) => query2.is(column, value)
+  ) : queryWithIn;
+  const { data, error } = await queryWithIs.select().single();
+  if (error) throw toError(error);
+  return data;
+}, toError);
+const deleteEntities = (client, table, where, is, wherein, schema) => functype.IO.tryAsync(async () => {
+  const tableQuery = schema ? client.schema(schema).from(table) : client.from(table);
+  const baseQuery = tableQuery.delete().match(where);
+  const queryWithIn = wherein ? functype.List(Object.entries(wherein)).foldLeft(baseQuery)(
+    (query2, [column, values]) => query2.in(column, values)
+  ) : baseQuery;
+  const queryWithIs = is ? functype.List(Object.entries(is)).foldLeft(queryWithIn)(
+    (query2, [column, value]) => query2.is(column, value)
+  ) : queryWithIn;
+  const { data, error } = await queryWithIs.select();
+  if (error) throw toError(error);
+  return functype.List(data);
+}, toError);
+const softDeleteEntity = (client, table, where, is, wherein, schema) => functype.IO.tryAsync(async () => {
+  const tableQuery = schema ? client.schema(schema).from(table) : client.from(table);
+  const baseQuery = tableQuery.update({ deleted: (/* @__PURE__ */ new Date()).toISOString() }).match(where);
+  const queryWithIn = wherein ? functype.List(Object.entries(wherein)).foldLeft(baseQuery)(
+    (query2, [column, values]) => query2.in(column, values)
+  ) : baseQuery;
+  const queryWithIs = is ? functype.List(Object.entries(is)).foldLeft(queryWithIn)(
+    (query2, [column, value]) => query2.is(column, value)
+  ) : queryWithIn;
+  const { data, error } = await queryWithIs.select().single();
+  if (error) throw toError(error);
+  return data;
+}, toError);
+const softDeleteEntities = (client, table, where, is, wherein, schema) => functype.IO.tryAsync(async () => {
+  const tableQuery = schema ? client.schema(schema).from(table) : client.from(table);
+  const baseQuery = tableQuery.update({ deleted: (/* @__PURE__ */ new Date()).toISOString() }).match(where);
+  const queryWithIn = wherein ? functype.List(Object.entries(wherein)).foldLeft(baseQuery)(
+    (query2, [column, values]) => query2.in(column, values)
+  ) : baseQuery;
+  const queryWithIs = is ? functype.List(Object.entries(is)).foldLeft(queryWithIn)(
+    (query2, [column, value]) => query2.is(column, value)
+  ) : queryWithIn;
+  const { data, error } = await queryWithIs.select();
+  if (error) throw toError(error);
+  return functype.List(data);
+}, toError);
 const query = (client, table, where = {}, is, wherein, order, schema) => {
   return createQuery(client, table, where, is, wherein, order, void 0, schema);
 };
-function MultiMutationQuery(promise) {
-  const result = Object.assign(promise, {
-    many: () => promise,
+function MultiMutationQuery(task) {
+  return {
+    many: () => task,
     manyOrThrow: async () => {
-      const taskResult = await promise;
-      return taskResult.orThrow();
+      return task.runOrThrow();
     },
-    execute: () => promise,
+    execute: () => task,
     executeOrThrow: async () => {
-      const taskResult = await promise;
-      return taskResult.orThrow();
+      return task.runOrThrow();
     }
-  });
-  return result;
+  };
 }
-function SingleMutationQuery(promise) {
-  const result = Object.assign(promise, {
-    one: () => promise.then((outcome) => outcome.map((value) => functype.Option(value))),
+function SingleMutationQuery(task) {
+  return {
+    one: () => task.map((value) => functype.Option(value)),
     oneOrThrow: async () => {
-      const taskResult = await promise;
-      return taskResult.orThrow();
+      return task.runOrThrow();
     },
-    execute: () => promise.then((outcome) => outcome.map((value) => functype.Option(value))),
+    execute: () => task.map((value) => functype.Option(value)),
     executeOrThrow: async () => {
-      const taskResult = await promise;
-      const value = taskResult.orThrow();
+      const value = await task.runOrThrow();
       return functype.Option(value);
     }
-  });
-  return result;
+  };
 }
 function getSoftDeleteMode(softDelete) {
   return softDelete ? "exclude" : "include";
@@ -868,7 +774,7 @@ function createGetItemQuery(client, name, whereConditions, is, softDeleteMode, s
     schema
   );
 }
-function createGetItemsQuery(client, name, whereConditions, is, wherein, order, softDeleteMode, schema, comparison) {
+function createGetItemsQuery(client, name, whereConditions, is, wherein, order, softDeleteMode, schema, comparison, not) {
   return createQuery(
     client,
     name,
@@ -881,7 +787,8 @@ function createGetItemsQuery(client, name, whereConditions, is, wherein, order,
       appliedByDefault: true
     },
     schema,
-    comparison
+    comparison,
+    not
   );
 }
 function createAddItemsMutation(client, name, items, schema) {
@@ -948,7 +855,8 @@ function makeGetItems(client, name, softDeleteMode, schema) {
     lt,
     neq,
     like,
-    ilike
+    ilike,
+    not
   } = {}) {
     return createGetItemsQuery(
       client,
@@ -959,7 +867,8 @@ function makeGetItems(client, name, softDeleteMode, schema) {
       order,
       softDeleteMode,
       schema,
-      { gte, gt, lte, lt, neq, like, ilike }
+      { gte, gt, lte, lt, neq, like, ilike },
+      not
     );
   };
 }
@@ -977,7 +886,7 @@ function makePartitionedGetItem(client, name, partitionField, softDeleteMode, sc
   };
 }
 function makePartitionedGetItems(client, name, partitionField, softDeleteMode, schema) {
-  return function getItems(partitionKey, { where, is, wherein, order, gte, gt, lte, lt, neq, like, ilike } = {}) {
+  return function getItems(partitionKey, { where, is, wherein, order, gte, gt, lte, lt, neq, like, ilike, not } = {}) {
     const whereConditions = buildWhereWithPartition(partitionField, partitionKey, where);
     return createGetItemsQuery(
       client,
@@ -988,7 +897,8 @@ function makePartitionedGetItems(client, name, partitionField, softDeleteMode, s
       order,
       softDeleteMode,
       schema,
-      { gte, gt, lte, lt, neq, like, ilike }
+      { gte, gt, lte, lt, neq, like, ilike },
+      not
     );
   };
 }
@@ -1275,18 +1185,14 @@ const PartitionedEntity = (client, name, config) => {
     deleteItems: makePartitionedDeleteItems(client, name, partitionField, config.softDelete, schema)
   };
 };
-Object.defineProperty(exports, "Err", {
+Object.defineProperty(exports, "IO", {
   enumerable: true,
-  get: () => functype.Err
+  get: () => functype.IO
 });
 Object.defineProperty(exports, "List", {
   enumerable: true,
   get: () => functype.List
 });
-Object.defineProperty(exports, "Ok", {
-  enumerable: true,
-  get: () => functype.Ok
-});
 Object.defineProperty(exports, "Option", {
   enumerable: true,
   get: () => functype.Option