@lunora/do 1.0.0-alpha.5 → 1.0.0-alpha.50

package/dist/packem_shared/RANK_TIEBREAK-C6blLR5K.mjs

@@ -1 +0,0 @@
-export { R as RANK_TIEBREAK, e as encodePartitionKey, m as matchesRankStaticWhere, c as rankKeyFromDoc, r as rankTableName, a as resolveRankPartition, s as sortColumnName } from './rank-CrkEIpF4.mjs';

package/dist/packem_shared/RLS_UNWRAP_SYMBOL-EtGQdC9d.mjs

@@ -1,132 +0,0 @@
-const RLS_UNWRAP_SYMBOL = /* @__PURE__ */ Symbol.for("lunora.ctxdb.rls-unwrap");
-class RlsRequiredError extends Error {
-  code = "RLS_REQUIRED";
-  status = 403;
-  table;
-  constructor(table) {
-    super(
-      `ctx.db access to "${table}" is denied: the schema is marked .rls("required"), so this table is protected. Apply RLS with .use(rls(policies)) in the procedure, or mark the table .public() to opt it out.`
-    );
-    this.name = "RlsRequiredError";
-    this.table = table;
-  }
-}
-const guardWriter = (raw, schema, tableOfId) => {
-  if (schema.rlsMode !== "required") {
-    return raw;
-  }
-  const base = raw;
-  const isProtected = (tableName) => {
-    const definition = schema.tables[tableName];
-    return definition !== void 0 && definition.isPublic !== true;
-  };
-  const guardTable = (tableName) => {
-    if (isProtected(tableName)) {
-      throw new RlsRequiredError(tableName);
-    }
-  };
-  const guardById = async (id, expectedTable) => {
-    if (expectedTable !== void 0) {
-      guardTable(expectedTable);
-      return;
-    }
-    const tableName = await tableOfId(id);
-    if (tableName !== void 0) {
-      guardTable(tableName);
-    }
-  };
-  const baseRankBefore = base.rankBefore;
-  const guarded = {
-    ...raw,
-    [RLS_UNWRAP_SYMBOL]: raw,
-    aggregate: (tableName, options) => {
-      guardTable(tableName);
-      return base.aggregate(tableName, options);
-    },
-    count: (tableName, whereOrArgs) => {
-      guardTable(tableName);
-      return base.count(tableName, whereOrArgs);
-    },
-    delete: async (id, expectedTable, options) => {
-      await guardById(id, expectedTable);
-      return base.delete(id, expectedTable, options);
-    },
-    deleteMany: async (ids, options, expectedTable) => {
-      for (const id of ids) {
-        await guardById(id, expectedTable);
-      }
-      return base.deleteMany(ids, options, expectedTable);
-    },
-    findFirst: (tableName, args) => {
-      guardTable(tableName);
-      return base.findFirst(tableName, args);
-    },
-    findFirstOrThrow: (tableName, args) => {
-      guardTable(tableName);
-      return base.findFirstOrThrow(tableName, args);
-    },
-    findMany: (tableName, args) => {
-      guardTable(tableName);
-      return base.findMany(tableName, args);
-    },
-    get: async (id, expectedTable) => {
-      await guardById(id, expectedTable);
-      return base.get(id, expectedTable);
-    },
-    groupBy: (tableName, options) => {
-      guardTable(tableName);
-      return base.groupBy(tableName, options);
-    },
-    insert: (tableName, document, options) => {
-      guardTable(tableName);
-      return base.insert(tableName, document, options);
-    },
-    insertMany: (tableName, documents, options) => {
-      guardTable(tableName);
-      return base.insertMany(tableName, documents, options);
-    },
-    insertManyUnsafe: (tableName, documents, options) => {
-      guardTable(tableName);
-      return base.insertManyUnsafe(tableName, documents, options);
-    },
-    patch: async (id, patch, expectedTable) => {
-      await guardById(id, expectedTable);
-      return base.patch(id, patch, expectedTable);
-    },
-    patchMany: async (patches, options, expectedTable) => {
-      for (const entry of patches) {
-        await guardById(entry.id, expectedTable);
-      }
-      return base.patchMany(patches, options, expectedTable);
-    },
-    query: (tableName) => {
-      guardTable(tableName);
-      return base.query(tableName);
-    },
-    rank: (tableName, indexName, options) => {
-      guardTable(tableName);
-      return base.rank(tableName, indexName, options);
-    },
-    rankPage: (tableName, indexName, options) => {
-      guardTable(tableName);
-      return base.rankPage(tableName, indexName, options);
-    },
-    replace: async (id, document, expectedTable) => {
-      await guardById(id, expectedTable);
-      return base.replace(id, document, expectedTable);
-    },
-    restore: async (id, expectedTable) => {
-      await guardById(id, expectedTable);
-      return base.restore?.(id, expectedTable);
-    }
-  };
-  if (baseRankBefore) {
-    guarded["rankBefore"] = (tableName, indexName, options) => {
-      guardTable(tableName);
-      return baseRankBefore(tableName, indexName, options);
-    };
-  }
-  return guarded;
-};
-
-export { RLS_UNWRAP_SYMBOL, RlsRequiredError, guardWriter };