@rebasepro/common 0.17.3 → 0.18.0

package/README.md

@@ -8,6 +8,10 @@ Shared utilities, collection registry, data driver adapter, and fluent query bui
 pnpm add @rebasepro/common
 ```
 
+ESM-only: `"type": "module"` with no CommonJS build, so it is loaded with
+`import`. `require()` of it resolves only on Node 22.12+, which supports
+`require(esm)`.
+
 ## What This Package Does
 
 `@rebasepro/common` is the lowest-level shared logic layer in the Rebase frontend stack. It provides:

package/dist/collections/CollectionRegistry.d.ts

@@ -9,7 +9,7 @@ export declare class CollectionRegistry {
     private dataSources;
     /**
      * Global lifecycle callbacks applied to every collection.
-     * Runs on all data paths (REST, WebSocket, `rebase.data`).
+     * Runs on all data paths (REST, WebSocket, `rebase.dataAsAdmin`).
      * Execution order: global → collection → property callbacks.
      */
     private _globalCallbacks?;

package/dist/collections/default-collections.d.ts

@@ -11,90 +11,21 @@
  * `config/collections/users.ts` carries the presentation for projects that want this
  * collection in their panel, which is also where it is editable.
  */
-export declare const defaultUsersCollection: import("@rebasepro/types").PostgresCollectionConfig<import("@rebasepro/types").InferEntityType<{
-    readonly id: {
-        readonly name: "ID";
-        readonly type: "string";
-        readonly isId: "uuid";
-    };
-    readonly email: {
-        readonly name: "Email";
-        readonly type: "string";
-        readonly validation: {
-            readonly required: true;
-            readonly unique: true;
-        };
-    };
-    readonly displayName: {
-        readonly name: "Name";
-        readonly type: "string";
-        readonly columnName: "display_name";
-        readonly validation: {
-            readonly required: true;
-        };
-    };
-    readonly photoURL: {
-        readonly name: "Photo URL";
-        readonly type: "string";
-        readonly columnName: "photo_url";
-    };
-    readonly roles: {
-        readonly name: "Roles";
-        readonly type: "array";
-        readonly columnType: "text[]";
-        readonly of: {
-            readonly name: "Role";
-            readonly type: "string";
-            readonly enum: {
-                readonly admin: "Admin";
-                readonly editor: "Editor";
-                readonly viewer: "Viewer";
-            };
-        };
-    };
-    readonly passwordHash: {
-        readonly name: "Password Hash";
-        readonly type: "string";
-        readonly columnName: "password_hash";
-        readonly excludeFromApi: true;
-    };
-    readonly emailVerified: {
-        readonly name: "Email Verified";
-        readonly type: "boolean";
-        readonly columnName: "email_verified";
-        readonly defaultValue: false;
-    };
-    readonly emailVerificationToken: {
-        readonly name: "Email Verification Token";
-        readonly type: "string";
-        readonly columnName: "email_verification_token";
-        readonly excludeFromApi: true;
-    };
-    readonly emailVerificationSentAt: {
-        readonly name: "Email Verification Sent At";
-        readonly type: "date";
-        readonly columnName: "email_verification_sent_at";
-    };
-    readonly metadata: {
-        readonly name: "Metadata";
-        readonly type: "map";
-        readonly keyValue: true;
-        readonly properties: {};
-        readonly defaultValue: {};
-    };
-    readonly createdAt: {
-        readonly name: "Created At";
-        readonly type: "date";
-        readonly columnName: "created_at";
-        readonly autoValue: "on_create";
-    };
-    readonly updatedAt: {
-        readonly name: "Updated At";
-        readonly type: "date";
-        readonly columnName: "updated_at";
-        readonly autoValue: "on_update";
-    };
-}>, import("@rebasepro/types").User> & {
+export declare const defaultUsersCollection: import("@rebasepro/types").PostgresCollectionConfig<{
+    email: string;
+    displayName: string;
+} & {
+    id?: string | undefined;
+    metadata?: import("@rebasepro/types").InferEntityType<{}> | undefined;
+    photoURL?: string | undefined;
+    roles?: string[] | undefined;
+    passwordHash?: string | undefined;
+    emailVerified?: boolean | undefined;
+    emailVerificationToken?: string | undefined;
+    emailVerificationSentAt?: Date | undefined;
+    createdAt?: Date | undefined;
+    updatedAt?: Date | undefined;
+}, import("@rebasepro/types").User> & {
     properties: {
         readonly id: {
             readonly name: "ID";

package/dist/data/buildRebaseData.d.ts

@@ -57,7 +57,7 @@ export declare function wrapAsSdkData(entityData: RebaseData): RebaseSdkData;
  * Build a flat {@link RebaseSdkData} from a `DataDriver`.
  *
  * This is the developer-facing SDK data layer used by backend framework
- * callbacks & scripts (`context.data` / `rebase.data`). It returns flat rows —
+ * callbacks & scripts (`context.data` / `rebase.dataAsAdmin`). It returns flat rows —
  * identical in shape to the frontend SDK client, down to how a relation is
  * served: a foreign key stays a foreign key, and a relation named in `include`
  * arrives as the target's own columns. The `{ __type: "relation" }` envelope is

package/dist/data/filter-dialect.d.ts

@@ -105,10 +105,21 @@ export declare function deserializeFilter(query: Record<string, unknown>): Filte
 /**
  * Serialize a `LogicalCondition` or `FilterCondition` to its wire-format string.
  *
+ * Leaf encoding is {@link serializeOperatorAndValue}, the same function
+ * `serializeTuple` uses, so `null`, the empty list and an unknown operator
+ * behave identically inside a group and in a query parameter.
+ *
+ * @throws {TypeError} when a leaf names an operator this dialect does not have.
+ * It used to fall back to `eq`, which turned `age >= 18` into `age = 18` with
+ * no diagnostic anywhere.
+ *
  * @example
  * serializeLogicalCondition({ column: "status", operator: "==", value: "active" })
  * // → "status.eq.active"
  *
+ * serializeLogicalCondition({ column: "deleted_at", operator: "==", value: null })
+ * // → "deleted_at.isnull.null"
+ *
  * serializeLogicalCondition({ type: "or", conditions: [...] })
  * // → "or(status.eq.active,status.eq.pending)"
  */

package/dist/data/sort-dialect.d.ts

@@ -98,17 +98,29 @@ export declare function serializeOrderBy(orderBy?: OrderBySpec | string): string
 /**
  * Deserialize a wire-format `"field:direction"` string into an {@link OrderByTuple}.
  *
- * Lenient parsing (matches existing server behaviour):
+ * Lenient parsing:
  * - Bare field name (no colon): `"name"` → `["name", "asc"]`
  * - Unknown direction: `"name:foo"` → `["name", "asc"]`
- * - Empty / falsy input: → `undefined`
+ * - Empty / falsy input, or a blank field name: → `undefined`
+ *
+ * The leniency is this end's alone; the *server* refuses the same value. This
+ * used to say "matches existing server behaviour", and it stopped being true
+ * when `parseOrderByParam` grew a strict direction check: `?orderBy=name:foo`
+ * now answers `400 INVALID_ORDER_BY` ("entry 0 has direction 'foo'"). The split
+ * is deliberate — see {@link parseOrderBySpecStrict} — because a value this
+ * function is handed was produced by {@link serializeOrderBy} a moment earlier,
+ * and one that reaches the server came from a stranger.
+ *
+ * A blank field is `undefined` rather than `[" ", "asc"]`: whitespace is not a
+ * field name, and the tuple it used to produce could not be re-encoded — the
+ * only value in this codec that survived a decode and failed the next encode.
  *
  * Reads the single-key shorthand only. For a value that may carry several keys,
  * use {@link deserializeOrderByList} — handed a JSON array this returns the
  * whole array as one nonsensical field name.
  *
  * @param raw - The wire-format string from an HTTP query parameter.
- * @returns The canonical tuple, or `undefined` if the input is empty/falsy.
+ * @returns The canonical tuple, or `undefined` if the input names no field.
  */
 export declare function deserializeOrderBy(raw?: string): OrderByTuple | undefined;
 /**