supabase-typed-query 0.9.4 → 0.10.0

package/README.md

@@ -24,6 +24,15 @@ pnpm add supabase-typed-query functype
 yarn add supabase-typed-query functype
 ```
 
+### Compatibility
+
+| Dependency              | Version    | Notes                               |
+| ----------------------- | ---------- | ----------------------------------- |
+| `@supabase/supabase-js` | `^2.0.0`   | Tested with 2.86.x                  |
+| `functype`              | `>=0.20.1` | Required for error handling         |
+| TypeScript              | `>=5.0`    | Recommended for best type inference |
+| Node.js                 | `>=18`     | Required                            |
+
 ## Quick Start
 
 ### 1. Set up your database types

package/dist/index.js

@@ -47,7 +47,7 @@ const log = {
   info: (msg) => process.env.NODE_ENV !== "test" && console.info(`[supabase-typed-query] ${msg}`)
 };
 const TABLES_WITHOUT_DELETED = /* @__PURE__ */ new Set([]);
-const wrapAsync$1 = (fn) => {
+const wrapAsync$2 = (fn) => {
   return fn();
 };
 const QueryBuilder = (client, config) => {
@@ -415,7 +415,7 @@ const QueryBuilder = (client, config) => {
      * Execute query expecting exactly one result
      */
     one: () => {
-      return wrapAsync$1(async () => {
+      return wrapAsync$2(async () => {
         try {
           const query2 = buildSupabaseQuery();
           const { data, error } = await query2.single();
@@ -439,7 +439,7 @@ const QueryBuilder = (client, config) => {
      * Execute query expecting zero or more results
      */
     many: () => {
-      return wrapAsync$1(async () => {
+      return wrapAsync$2(async () => {
         try {
           const query2 = buildSupabaseQuery();
           const { data, error } = await query2;
@@ -460,7 +460,7 @@ const QueryBuilder = (client, config) => {
      * Execute query expecting first result from potentially multiple
      */
     first: () => {
-      return wrapAsync$1(async () => {
+      return wrapAsync$2(async () => {
         const manyResult = await QueryBuilder(client, config).many();
         const list = manyResult.orThrow();
         if (list.isEmpty) {
@@ -504,7 +504,7 @@ const createMappedQuery = (sourceQuery, mapFn) => {
       return createMappedQuery(filteredQuery, mapFn);
     },
     one: () => {
-      return wrapAsync$1(async () => {
+      return wrapAsync$2(async () => {
         const maybeItemResult = await sourceQuery.one();
         const maybeItem = maybeItemResult.orThrow();
         return maybeItem.fold(
@@ -514,14 +514,14 @@ const createMappedQuery = (sourceQuery, mapFn) => {
       });
     },
     many: () => {
-      return wrapAsync$1(async () => {
+      return wrapAsync$2(async () => {
         const itemsResult = await sourceQuery.many();
         const items = itemsResult.orThrow();
         return functype.Ok(items.map(mapFn));
       });
     },
     first: () => {
-      return wrapAsync$1(async () => {
+      return wrapAsync$2(async () => {
         const maybeItemResult = await sourceQuery.first();
         const maybeItem = maybeItemResult.orThrow();
         return maybeItem.fold(
@@ -572,6 +572,73 @@ 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]));
+      }
+      return functype.Ok(functype.Option(data));
+    } catch (error) {
+      return functype.Err(toError(error));
+    }
+  });
+  const oneOrThrow = async () => {
+    const result = await one();
+    const option = result.orThrow();
+    return option.fold(
+      () => {
+        throw new Error("RPC call returned no result");
+      },
+      (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 manyOrThrow = async () => {
+    const result = await many();
+    return result.orThrow();
+  };
+  return {
+    one,
+    oneOrThrow,
+    many,
+    manyOrThrow
+  };
+};
 const wrapAsync = (fn) => {
   return fn();
 };
@@ -1168,6 +1235,7 @@ exports.getEntity = getEntity;
 exports.isMappedQuery = isMappedQuery;
 exports.isQuery = isQuery;
 exports.query = query;
+exports.rpc = rpc;
 exports.softDeleteEntities = softDeleteEntities;
 exports.softDeleteEntity = softDeleteEntity;
 exports.toError = toError;