supabase-typed-query 0.5.0 → 0.7.0

package/README.md

@@ -12,6 +12,7 @@ Type-safe query builder and entity pattern for Supabase with TypeScript.
 - 🔄 **Composable queries** - Mix and match conditions, filters, and transformations
 - 🗑️ **Soft delete support** - Built-in soft delete filtering with per-query overrides
 - 🏢 **Multi-tenancy ready** - Automatic partition key filtering for tenant isolation
+- 🗄️ **Custom schema support** - Query tables in any PostgreSQL schema, not just public
 
 ## Installation
 
@@ -150,6 +151,42 @@ const AdminEntity = Entity(supabase, "users", {
 })
 ```
 
+### Custom Schema Support
+
+Query tables in any PostgreSQL schema (not just the default `public` schema):
+
+```typescript
+import { Entity, PartitionedEntity, query } from "supabase-typed-query"
+
+// Entity with custom schema
+const InventoryEntity = Entity(supabase, "items", {
+  softDelete: false,
+  schema: "inventory", // Uses client.schema("inventory").from("items")
+})
+
+const items = await InventoryEntity.getItems({ where: { active: true } }).many()
+
+// PartitionedEntity with custom schema
+const TenantItemsEntity = PartitionedEntity(supabase, "items", {
+  partitionField: "tenant_id",
+  softDelete: true,
+  schema: "tenant_data",
+})
+
+// Query API with custom schema (7th parameter)
+const results = await query(
+  supabase,
+  "items",
+  { active: true },
+  undefined, // is conditions
+  undefined, // wherein conditions
+  undefined, // order
+  "inventory", // schema
+).many()
+```
+
+When no schema is specified, queries use the default `public` schema via `client.from()`. When a schema is specified, queries use `client.schema(name).from(table)`.
+
 ### Multi-Tenancy with Partition Keys
 
 Use partition keys to automatically scope queries to a tenant or partition:
@@ -253,7 +290,13 @@ const posts = await query(supabase, "posts", {
 ### Entity Configuration
 
 - `softDelete: boolean` - (Required) When `true`, automatically excludes soft-deleted items; when `false`, includes them
-- `partitionKey?: Record<string, unknown>` - (Optional) Automatically applies partition filtering (e.g., `{ tenant_id: "123" }` for multi-tenancy)
+- `schema?: string` - (Optional) PostgreSQL schema to query from (defaults to `"public"`)
+
+### PartitionedEntity Configuration
+
+- `partitionField: string` - (Required) Column name used for partition filtering (e.g., `"tenant_id"`)
+- `softDelete: boolean` - (Required) When `true`, automatically excludes soft-deleted items
+- `schema?: string` - (Optional) PostgreSQL schema to query from (defaults to `"public"`)
 
 ## Requirements
 

package/dist/index.js

@@ -52,8 +52,8 @@ const wrapAsync$1 = (fn) => {
 };
 const QueryBuilder = (client, config) => {
   const buildSupabaseQuery = () => {
-    const { table, conditions, order, limit, offset } = config;
-    const baseQuery = client.from(table);
+    const { table, conditions, order, limit, offset, schema } = config;
+    const baseQuery = schema ? client.schema(schema).from(table) : client.from(table);
     const queryWithConditions = conditions.length === 1 ? applyCondition(baseQuery, conditions[0]) : applyOrConditions(baseQuery, conditions);
     const queryWithOrder = order ? queryWithConditions.order(order[0], order[1]) : queryWithConditions;
     const finalQuery = (() => {
@@ -555,13 +555,14 @@ const createMappedQuery = (sourceQuery, mapFn) => {
     }
   };
 };
-const createQuery = (client, table, where = {}, is, wherein, order, softDeleteConfig) => {
+const createQuery = (client, table, where = {}, is, wherein, order, softDeleteConfig, schema) => {
   const config = {
     table,
     conditions: [{ where, is, wherein }],
     order,
     softDeleteMode: softDeleteConfig?.mode,
-    softDeleteAppliedByDefault: softDeleteConfig?.appliedByDefault
+    softDeleteAppliedByDefault: softDeleteConfig?.appliedByDefault,
+    schema
   };
   return QueryBuilder(client, config);
 };
@@ -574,9 +575,10 @@ const isMappedQuery = (obj) => {
 const wrapAsync = (fn) => {
   return fn();
 };
-const getEntity = (client, table, where, is) => wrapAsync(async () => {
+const getEntity = (client, table, where, is, schema) => wrapAsync(async () => {
   try {
-    const baseQuery = client.from(table).select("*").match(where);
+    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;
@@ -592,9 +594,10 @@ const getEntity = (client, table, where, is) => wrapAsync(async () => {
 const getEntities = (client, table, where = {}, is, wherein, order = [
   "id",
   { ascending: true }
-]) => wrapAsync(async () => {
+], schema) => wrapAsync(async () => {
   try {
-    const baseQuery = client.from(table).select("*").match(where);
+    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;
@@ -611,9 +614,10 @@ const getEntities = (client, table, where = {}, is, wherein, order = [
     return functype.Err(toError(error));
   }
 });
-const addEntities = (client, table, entities) => wrapAsync(async () => {
+const addEntities = (client, table, entities, schema) => wrapAsync(async () => {
   try {
-    const { data, error } = await client.from(table).insert(entities).select();
+    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));
     }
@@ -622,9 +626,10 @@ const addEntities = (client, table, entities) => wrapAsync(async () => {
     return functype.Err(toError(error));
   }
 });
-const updateEntity = (client, table, entities, where, is, wherein) => wrapAsync(async () => {
+const updateEntity = (client, table, entities, where, is, wherein, schema) => wrapAsync(async () => {
   try {
-    const baseQuery = client.from(table).update(entities).match(where);
+    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;
@@ -640,10 +645,11 @@ const updateEntity = (client, table, entities, where, is, wherein) => wrapAsync(
     return functype.Err(toError(error));
   }
 });
-const upsertEntities = (client, table, entities, identity = "id", where, is, wherein) => wrapAsync(async () => {
+const upsertEntities = (client, table, entities, identity = "id", where, is, wherein, schema) => wrapAsync(async () => {
   try {
     const onConflict = Array.isArray(identity) ? identity.join(",") : identity;
-    const baseQuery = client.from(table).upsert(entities, { onConflict }).match(where ?? {});
+    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;
@@ -659,8 +665,8 @@ const upsertEntities = (client, table, entities, identity = "id", where, is, whe
     return functype.Err(toError(error));
   }
 });
-const query = (client, table, where = {}, is, wherein, order) => {
-  return createQuery(client, table, where, is, wherein, order);
+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, {
@@ -704,54 +710,90 @@ function buildWhereWithPartitionAndId(partitionField, partitionKey, id, where) {
   const partitionCondition = { [partitionField]: partitionKey };
   return { ...partitionCondition, ...where, id };
 }
-function createGetItemQuery(client, name, whereConditions, is, softDeleteMode) {
-  return createQuery(client, name, whereConditions, is, void 0, void 0, {
-    mode: softDeleteMode,
-    appliedByDefault: true
-  });
+function createGetItemQuery(client, name, whereConditions, is, softDeleteMode, schema) {
+  return createQuery(
+    client,
+    name,
+    whereConditions,
+    is,
+    void 0,
+    void 0,
+    {
+      mode: softDeleteMode,
+      appliedByDefault: true
+    },
+    schema
+  );
 }
-function createGetItemsQuery(client, name, whereConditions, is, wherein, order, softDeleteMode) {
-  return createQuery(client, name, whereConditions, is, wherein, order, {
-    mode: softDeleteMode,
-    appliedByDefault: true
-  });
+function createGetItemsQuery(client, name, whereConditions, is, wherein, order, softDeleteMode, schema) {
+  return createQuery(
+    client,
+    name,
+    whereConditions,
+    is,
+    wherein,
+    order,
+    {
+      mode: softDeleteMode,
+      appliedByDefault: true
+    },
+    schema
+  );
 }
-function createAddItemsMutation(client, name, items) {
-  return MultiMutationQuery(addEntities(client, name, items));
+function createAddItemsMutation(client, name, items, schema) {
+  return MultiMutationQuery(
+    addEntities(client, name, items, schema)
+  );
 }
-function createUpdateItemMutation(client, name, item, whereConditions, is, wherein) {
+function createUpdateItemMutation(client, name, item, whereConditions, is, wherein, schema) {
   return SingleMutationQuery(
-    updateEntity(client, name, item, whereConditions, is, wherein)
+    updateEntity(client, name, item, whereConditions, is, wherein, schema)
   );
 }
-function createUpdateItemsMutation(client, name, data, where, is, wherein) {
+function createUpdateItemsMutation(client, name, data, where, is, wherein, schema) {
   return MultiMutationQuery(
-    upsertEntities(client, name, [data], void 0, where, is, wherein)
+    upsertEntities(client, name, [data], void 0, where, is, wherein, schema)
   );
 }
-function createUpsertItemsMutation(client, name, items, identity) {
+function createUpsertItemsMutation(client, name, items, identity, schema) {
   return MultiMutationQuery(
-    upsertEntities(client, name, items, identity, void 0, void 0, void 0)
+    upsertEntities(client, name, items, identity, void 0, void 0, void 0, schema)
   );
 }
-function makeGetItem(client, name, softDeleteMode) {
+function makeGetItem(client, name, softDeleteMode, schema) {
   return function getItem({ id, where, is }) {
     const whereConditions = { ...where, id };
-    return createGetItemQuery(client, name, whereConditions, is, softDeleteMode);
+    return createGetItemQuery(client, name, whereConditions, is, softDeleteMode, schema);
   };
 }
-function makeGetItems(client, name, softDeleteMode) {
+function makeGetItems(client, name, softDeleteMode, schema) {
   return function getItems({ where, is, wherein, order } = {}) {
-    return createGetItemsQuery(client, name, where, is, wherein, order, softDeleteMode);
+    return createGetItemsQuery(
+      client,
+      name,
+      where,
+      is,
+      wherein,
+      order,
+      softDeleteMode,
+      schema
+    );
   };
 }
-function makePartitionedGetItem(client, name, partitionField, softDeleteMode) {
+function makePartitionedGetItem(client, name, partitionField, softDeleteMode, schema) {
   return function getItem(partitionKey, { id, where, is }) {
     const whereConditions = buildWhereWithPartitionAndId(partitionField, partitionKey, id, where);
-    return createGetItemQuery(client, name, whereConditions, is, softDeleteMode);
+    return createGetItemQuery(
+      client,
+      name,
+      whereConditions,
+      is,
+      softDeleteMode,
+      schema
+    );
   };
 }
-function makePartitionedGetItems(client, name, partitionField, softDeleteMode) {
+function makePartitionedGetItems(client, name, partitionField, softDeleteMode, schema) {
   return function getItems(partitionKey, { where, is, wherein, order } = {}) {
     const whereConditions = buildWhereWithPartition(partitionField, partitionKey, where);
     return createGetItemsQuery(
@@ -761,94 +803,128 @@ function makePartitionedGetItems(client, name, partitionField, softDeleteMode) {
       is,
       wherein,
       order,
-      softDeleteMode
+      softDeleteMode,
+      schema
     );
   };
 }
-function makeUpdateItem(client, name) {
+function makeUpdateItem(client, name, schema) {
   return function updateItem({ where, data, is, wherein }) {
-    return createUpdateItemMutation(client, name, data, where, is, wherein);
+    return createUpdateItemMutation(
+      client,
+      name,
+      data,
+      where,
+      is,
+      wherein,
+      schema
+    );
   };
 }
-function makePartitionedUpdateItem(client, name, partitionField) {
+function makePartitionedUpdateItem(client, name, partitionField, schema) {
   return function updateItem(partitionKey, { where, data, is, wherein }) {
     const whereConditions = buildWhereWithPartition(partitionField, partitionKey, where);
-    return createUpdateItemMutation(client, name, data, whereConditions, is, wherein);
+    return createUpdateItemMutation(
+      client,
+      name,
+      data,
+      whereConditions,
+      is,
+      wherein,
+      schema
+    );
   };
 }
-function makeUpdateItems(client, name) {
+function makeUpdateItems(client, name, schema) {
   return function updateItems({ where, data, is, wherein }) {
-    return createUpdateItemsMutation(client, name, data, where, is, wherein);
+    return createUpdateItemsMutation(
+      client,
+      name,
+      data,
+      where,
+      is,
+      wherein,
+      schema
+    );
   };
 }
-function makePartitionedUpdateItems(client, name, partitionField) {
+function makePartitionedUpdateItems(client, name, partitionField, schema) {
   return function updateItems(partitionKey, { where, data, is, wherein }) {
     const whereConditions = buildWhereWithPartition(partitionField, partitionKey, where);
-    return createUpdateItemsMutation(client, name, data, whereConditions, is, wherein);
+    return createUpdateItemsMutation(
+      client,
+      name,
+      data,
+      whereConditions,
+      is,
+      wherein,
+      schema
+    );
   };
 }
-function makeAddItems(client, name) {
+function makeAddItems(client, name, schema) {
   return function addItems({ items }) {
-    return createAddItemsMutation(client, name, items);
+    return createAddItemsMutation(client, name, items, schema);
   };
 }
-function makeUpsertItems(client, name) {
+function makeUpsertItems(client, name, schema) {
   return function upsertItems({
     items,
     identity = "id"
   }) {
-    return createUpsertItemsMutation(client, name, items, identity);
+    return createUpsertItemsMutation(client, name, items, identity, schema);
   };
 }
-function makePartitionedUpsertItems(client, name, _partitionField) {
+function makePartitionedUpsertItems(client, name, _partitionField, schema) {
   return function upsertItems(_partitionKey, { items, identity = "id" }) {
-    return createUpsertItemsMutation(client, name, items, identity);
+    return createUpsertItemsMutation(client, name, items, identity, schema);
   };
 }
 const Entity = (client, name, config) => {
   const softDeleteMode = getSoftDeleteMode(config.softDelete);
+  const { schema } = config;
   return {
     /**
      * Retrieve a single item from the table by ID.
      * @param params Query parameters including id, where conditions, and is conditions
      * @returns A chainable query that can be executed with .one(), .many(), or .first()
      */
-    getItem: makeGetItem(client, name, softDeleteMode),
+    getItem: makeGetItem(client, name, softDeleteMode, schema),
     /**
      * Get a list of items from the table filtered by conditions.
      * @param params Optional query parameters including where, is, wherein, and order
      * @returns A chainable query that can be executed with .one(), .many(), or .first()
      */
-    getItems: makeGetItems(client, name, softDeleteMode),
+    getItems: makeGetItems(client, name, softDeleteMode, schema),
     /**
      * Adds multiple items to the table.
      * @param params Parameters including items array
      * @returns A mutation query with OrThrow methods
      */
-    addItems: makeAddItems(client, name),
+    addItems: makeAddItems(client, name, schema),
     /**
      * Update a single item in the table.
      * @param params Update parameters including id, item data, and optional filters
      * @returns A mutation query with OrThrow methods
      */
-    updateItem: makeUpdateItem(client, name),
+    updateItem: makeUpdateItem(client, name, schema),
     /**
      * Update multiple items in the table.
      * @param params Update parameters including items array, identity, and optional filters
      * @returns A mutation query with OrThrow methods
      */
-    updateItems: makeUpdateItems(client, name),
+    updateItems: makeUpdateItems(client, name, schema),
     /**
      * Upsert multiple items with different data per row.
      * @param params Upsert parameters including items array and identity columns
      * @returns A mutation query with OrThrow methods
      */
-    upsertItems: makeUpsertItems(client, name)
+    upsertItems: makeUpsertItems(client, name, schema)
   };
 };
 const PartitionedEntity = (client, name, config) => {
   const softDeleteMode = getSoftDeleteMode(config.softDelete);
-  const { partitionField } = config;
+  const { partitionField, schema } = config;
   return {
     /**
      * Retrieve a single item from the table by ID within a partition.
@@ -856,35 +932,35 @@ const PartitionedEntity = (client, name, config) => {
      * @param params Query parameters including id, where conditions, and is conditions
      * @returns A chainable query that can be executed with .one(), .many(), or .first()
      */
-    getItem: makePartitionedGetItem(client, name, partitionField, softDeleteMode),
+    getItem: makePartitionedGetItem(client, name, partitionField, softDeleteMode, schema),
     /**
      * Get a list of items from the table within a partition.
      * @param partitionKey The partition key value (e.g., tenantId)
      * @param params Optional query parameters including where, is, wherein, and order
      * @returns A chainable query that can be executed with .one(), .many(), or .first()
      */
-    getItems: makePartitionedGetItems(client, name, partitionField, softDeleteMode),
+    getItems: makePartitionedGetItems(client, name, partitionField, softDeleteMode, schema),
     /**
      * Adds multiple items to the table.
      * Note: Items should include the partition key value in their data.
      * @param params Parameters including items array
      * @returns A mutation query with OrThrow methods
      */
-    addItems: makeAddItems(client, name),
+    addItems: makeAddItems(client, name, schema),
     /**
      * Update a single item in the table within a partition.
      * @param partitionKey The partition key value (e.g., tenantId)
      * @param params Update parameters including id, item data, and optional filters
      * @returns A mutation query with OrThrow methods
      */
-    updateItem: makePartitionedUpdateItem(client, name, partitionField),
+    updateItem: makePartitionedUpdateItem(client, name, partitionField, schema),
     /**
      * Update multiple items in the table within a partition.
      * @param partitionKey The partition key value (e.g., tenantId)
      * @param params Update parameters including items array, identity, and optional filters
      * @returns A mutation query with OrThrow methods
      */
-    updateItems: makePartitionedUpdateItems(client, name, partitionField),
+    updateItems: makePartitionedUpdateItems(client, name, partitionField, schema),
     /**
      * Upsert multiple items with different data per row within a partition.
      * Note: Items should include the partition key value in their data.
@@ -892,7 +968,7 @@ const PartitionedEntity = (client, name, config) => {
      * @param params Upsert parameters including items array and identity columns
      * @returns A mutation query with OrThrow methods
      */
-    upsertItems: makePartitionedUpsertItems(client, name)
+    upsertItems: makePartitionedUpsertItems(client, name, partitionField, schema)
   };
 };
 Object.defineProperty(exports, "Err", {