@rebasepro/common 0.22.0 → 0.24.0

package/dist/util/copy.d.ts

@@ -0,0 +1,33 @@
+import type { CollectionConfig, ResolvedRelation } from "@rebasepro/types";
+/**
+ * Whether a duplicate of a record may carry this relation's value.
+ *
+ * A duplicate is saved as a create, and a create writes every relation it
+ * carries. That is right where the link is the copy's own: a `belongsTo` key on
+ * the copy's row, or `manyToMany` links, which are new junction rows beside the
+ * original's — the targets are shared by design. It is wrong wherever the key
+ * lives on the other row. Writing a `hasMany` or a `hasOne` points the
+ * children's foreign key at the copy, which takes them away from the record
+ * that was copied: duplicating an author moved every one of their posts to the
+ * duplicate and left the original with none. A `via` is declared read-only,
+ * and its one-to-one writer re-points the target's key the same way.
+ *
+ * Exhaustive over the kinds, so a new one is a compile error here rather than
+ * a copy that quietly carries it.
+ */
+export declare function copyCarriesRelation(relation: ResolvedRelation): boolean;
+/**
+ * The values a duplicate of a record is created with: the original's, less
+ * its key and less every relation the copy cannot take without changing
+ * another row (see {@link copyCarriesRelation}).
+ *
+ * The key goes so the database, or the user, gives the copy its own. The
+ * relations go because the copy is written as a create, and a create writes
+ * them — for a child-held key that is a re-parent of rows the user never
+ * touched, with nothing on screen to say so.
+ *
+ * A relation property that does not resolve is left out as well: what writing
+ * it would do cannot be known here, and leaving a value out of a new record
+ * changes nothing that exists.
+ */
+export declare function getCopyValues<M extends Record<string, unknown>>(collection: CollectionConfig, values: Partial<M>): Partial<M>;

package/dist/util/entities.d.ts

@@ -99,7 +99,15 @@ export declare function applyDefaultValuesOnCreate<M extends Record<string, unkn
  * @group Driver
  */
 export declare function sanitizeData<M extends Record<string, unknown>>(values: EntityValues<M>, properties: Properties): Record<string, unknown>;
-export declare function getReferenceFrom<M extends Record<string, unknown>>(entity: Entity<M>): EntityReference;
+/**
+ * A reference to `entity`.
+ *
+ * @param path where the reference points, when that is not the path the
+ * entity is addressed by. A Firestore or MongoDB collection may declare a
+ * `path` for its store other than its slug, and a reference has to carry the
+ * stored one, where `entity.path` is the path the admin addresses it by.
+ */
+export declare function getReferenceFrom<M extends Record<string, unknown>>(entity: Entity<M>, path?: string): EntityReference;
 export declare function getRelationFrom<M extends Record<string, unknown>>(entity: Entity<M>): EntityRelation;
 /**
  * Normalize a value into a proper EntityRelation instance.

package/dist/util/index.d.ts

@@ -22,3 +22,5 @@ export * from "./pg-column-to-property.js";
 export * from "./string-column-length.js";
 export * from "./internal-tables.js";
 export * from "./sql-rows.js";
+export * from "./copy.js";
+export * from "./untrusted-envelope.js";

package/dist/util/policy/compileRulePolicies.d.ts

@@ -0,0 +1,32 @@
+import type { CollectionConfig, SecurityOperation, SecurityRule } from "@rebasepro/types";
+import { type PolicyCompileOptions } from "./policyToPostgres.js";
+/**
+ * One Postgres policy a security rule compiles to: its name and the clauses
+ * `CREATE POLICY` is given for it.
+ */
+export interface CompiledRulePolicy {
+    name: string;
+    operation: SecurityOperation;
+    /** `permissive` | `restrictive`, lower-case as the rule spells it. */
+    mode: "permissive" | "restrictive";
+    /** The `TO` list. Sorted, `["public"]` when the rule names none. */
+    roles: string[];
+    /** The `USING` clause, or `null` when the operation takes none. */
+    using: string | null;
+    /** The `WITH CHECK` clause, or `null` when the operation takes none. */
+    withCheck: string | null;
+}
+/**
+ * The policies one security rule compiles to — one per operation.
+ *
+ * The schema planner writes these into the database, and the Studio's RLS
+ * editor compares the database against them; both call this, so "what the code
+ * declares" has one meaning.
+ *
+ * The desugaring (`access` / `ownerField` / `roles` / structured condition /
+ * raw SQL → `PolicyExpression`) is {@link securityRuleToConditions}, and the SQL
+ * is {@link policyToPostgres}. What lives here is only the shape: which
+ * operations a rule expands to, which clauses each operation takes, and the
+ * deny-all fallback for a clause that compiled to nothing.
+ */
+export declare function compileRulePolicies(collection: CollectionConfig, rule: SecurityRule, options?: PolicyCompileOptions): CompiledRulePolicy[];

package/dist/util/policy/index.d.ts

@@ -2,3 +2,5 @@ export * from "./securityRuleToConditions.js";
 export * from "./sqlToPolicy.js";
 export * from "./policyToPostgres.js";
 export * from "./evaluatePolicy.js";
+export * from "./policyToSecurityRule.js";
+export * from "./compileRulePolicies.js";

package/dist/util/policy/policyToSecurityRule.d.ts

@@ -0,0 +1,27 @@
+import type { PostgresPolicy, SecurityRule } from "@rebasepro/types";
+/**
+ * The rule a Postgres policy compiles back from — a `pg_policies` row, or what
+ * a policy editor produced in that shape.
+ *
+ * One definition for every place that turns a policy into a rule: Studio's RLS
+ * editor ("Save" and "Import to codebase"), the collection editor's RLS tab
+ * ("Import to codebase") and "Import from table"
+ * (`buildCollectionFromTableMetadata`). The rule is what `db push` compiles back
+ * into the database, so anything this gets wrong is a policy that changes on
+ * the way back:
+ *
+ * - The `TO` list names *database* roles, which is `pgRoles`. `roles` holds
+ *   *application* roles and compiles to a `rebase.roles()` check: filed there,
+ *   `TO public` is a check no user passes, and on a restrictive policy — which
+ *   compiles to `NOT (roles) OR condition` — a gate every user passes.
+ *   `pgRoles` is omitted at the `public` default, so a rule that targets every
+ *   connection, nearly all of them, carries no advanced field it does not need.
+ * - The WITH CHECK is kept whether or not there is a USING beside it. Every
+ *   INSERT policy has only a check, and a rule with neither clause compiles to
+ *   `WITH CHECK (false)`, which stops every insert.
+ * - `mode` is written when the policy states one: a restrictive policy read
+ *   back as permissive is OR'd with every grant beside it.
+ * - Retired RLS helpers (`auth.uid()`) are respelled, as `sqlToPolicy` does
+ *   for what it reads, because this rule is written into the project's config.
+ */
+export declare function policyToSecurityRule(policy: Partial<PostgresPolicy>): SecurityRule;

package/dist/util/untrusted-envelope.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Wrap text that came out of an application's data in an explicit
+ * untrusted-data envelope, for a language model to read.
+ *
+ * A row is text somebody else wrote — a `body` column an anonymous visitor
+ * filled in, a support-ticket title — and an MCP tool hands it to the model on
+ * the same channel as the tool contract the model is following, in a session
+ * that also holds `update_document` and `delete_document`. So an instruction
+ * smuggled through a row is an instruction with reach. A fenced envelope does
+ * not solve prompt injection; handing the row over with no marking at all is
+ * below the floor.
+ *
+ * The fence has to be one the data cannot close. A fixed end marker is text any
+ * row can print, and whatever follows it would sit outside the block — the one
+ * place the envelope tells the model to trust. So each envelope's markers carry
+ * an id minted for this response, after the data was written, and a
+ * marker-like string inside the body is broken with a zero-width space so it
+ * does not read as one. The source is JSON-escaped (with `<` and `>` too), so
+ * it cannot end the opening marker early either.
+ *
+ * The remote MCP endpoint (`@rebasepro/server`) wraps with this. The local MCP
+ * server (`@rebasepro/mcp`) has its own copy, held to this one's output by a
+ * test in that package.
+ */
+export declare function untrustedEnvelope(source: string, body: string): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rebasepro/common",
-  "version": "0.22.0",
+  "version": "0.24.0",
   "description": "Rebase shared core — collection registry, data driver adapter and fluent query builder. No React dependency.",
   "keywords": [
     "rebase",
@@ -44,8 +44,8 @@
   "dependencies": {
     "fast-equals": "6.0.2",
     "json-logic-js": "^2.0.5",
-    "@rebasepro/utils": "0.22.0",
-    "@rebasepro/types": "0.22.0"
+    "@rebasepro/types": "0.24.0",
+    "@rebasepro/utils": "0.24.0"
   },
   "devDependencies": {
     "@jest/globals": "^30.4.1",

package/dist/util/callback-errors.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/util/internal-tables.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/util/permissions.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/util/table-name.test.d.ts

@@ -1 +0,0 @@
-export {};