@rebasepro/common 0.14.1 → 0.14.2-canary.g27a129e

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

@@ -18,6 +18,13 @@ import type { OrderBySpec, OrderByTuple } from "@rebasepro/types";
  * the same value; the two are told apart by whether the first element is
  * itself an array, which no field name ever is.
  *
+ * This is also where a {@link RelationAggregateSort} object stops being an
+ * object. Above this function a sort key may be either spelling; below it,
+ * every key is a string — which is what `OrderByTuple`, the REST parameter, the
+ * driver contract and the cursor all already were. Doing it here means the one
+ * place that already collapses the two *shapes* of a sort also collapses the
+ * two *spellings* of a key, rather than every consumer learning about both.
+ *
  * @returns The keys in order of significance, or `undefined` for no sort. An
  *   empty list also returns `undefined` — "sort by nothing" is no sort, and
  *   letting `[]` through would have every layer below re-deciding what it meant.

package/dist/index.es.js

@@ -1,4 +1,4 @@
-import { ALL_WHERE_FILTER_OPS, ANONYMOUS_USER_ID, ANONYMOUS_USER_IDS, CANONICAL_TO_REST, DEFAULT_DATA_SOURCE_KEY, DEFAULT_LIST_LIMIT, EntityReference, EntityRelation, NULL_OPS, REST_TO_CANONICAL, RLS_ROLES_SQL, RLS_UID_SQL, getDataSourceCapabilities, getDeclaredSubcollections, isAnonymousUid, isManyToMany, isPostgresCollectionConfig, isRelationalCollectionConfig, policy, rewriteLegacyRlsFunctions, toCanonicalOp } from "@rebasepro/types";
+import { ALL_WHERE_FILTER_OPS, ANONYMOUS_USER_ID, ANONYMOUS_USER_IDS, CANONICAL_TO_REST, DEFAULT_DATA_SOURCE_KEY, DEFAULT_LIST_LIMIT, EntityReference, EntityRelation, NULL_OPS, REST_TO_CANONICAL, RLS_ROLES_SQL, RLS_UID_SQL, getDataSourceCapabilities, getDeclaredSubcollections, isAnonymousUid, isManyToMany, isPostgresCollectionConfig, isRelationAggregateSort, isRelationalCollectionConfig, policy, rewriteLegacyRlsFunctions, sortKeyToString, toCanonicalOp } from "@rebasepro/types";
 import { deepClone, firstFreeKey, generateForeignKeyName, getIn, getPolicyNamesForRules, getPolicyOperations, isDefaultFieldConfigId, mergeDeep, prettifyIdentifier, randomString, removeFunctions, toSnakeCase, toWireKey } from "@rebasepro/utils";
 import jsonLogic from "json-logic-js";
 import { deepEqual } from "fast-equals";
@@ -486,7 +486,7 @@ function resolveRelation(relation, sourceCollection, propertyKey) {
 	const relationName = relation.relationName ?? propertyKey ?? toSnakeCase(targetCollection.slug);
 	const shared = {
 		relationName,
-		target,
+		target: () => unwrapModuleNamespace(target()),
 		targetSlug: targetCollection.slug,
 		onUpdate: relation.onUpdate,
 		onDelete: relation.onDelete,
@@ -554,35 +554,67 @@ function describe(relation, sourceCollection, propertyKey) {
 	return `Relation${name ? ` '${name}'` : ""} on '${sourceCollection.slug}'`;
 }
 /**
-* Call the `target` thunk, and translate the two ways an import cycle breaks it
-* into an error that names the cause.
+* A module namespace, unwrapped to the collection it exports.
+*
+* A cycle transpiled to CommonJS does not hand the importing module the
+* *default export* — it hands it the module object, `{ __esModule: true,
+* default: … }`, captured before the exporting module finished evaluating. The
+* `default` slot fills in later, so by the time a lazy `target` thunk runs the
+* collection is sitting right there, one level down. Returning the namespace is
+* never a thing a thunk means to do, and there is exactly one reading of it.
+*
+* Only unwrapped when the inner value is itself a collection: a `default` that
+* is not one is a genuinely wrong thunk, and it should reach the error below
+* rather than be quietly swapped in.
+*/
+function unwrapModuleNamespace(value) {
+	if (!value || typeof value !== "object") return value;
+	if (value.slug) return value;
+	const inner = value.default;
+	return inner && typeof inner === "object" && inner.slug ? inner : value;
+}
+/**
+* Call the `target` thunk, and translate the ways an import cycle breaks it into
+* an error that names the cause — or, where the value is recoverable, into the
+* collection the thunk meant.
 *
 * The thunk exists to defer the reference until every module has finished
-* evaluating, and for a cycle that closes at import time it does. What it cannot
-* defer is a cycle that leaves the binding permanently unusable, and there are
-* two shapes of that:
+* evaluating, and for a cycle that closes at import time it does. Two cycles
+* leave the binding permanently unusable:
 *
 *  - **ESM/TDZ.** `const` and `class` bindings in a not-yet-evaluated module are
 *    in the temporal dead zone, so reading one throws `ReferenceError: x is not
 *    defined`. The stack points at the thunk — a one-line arrow function that is
 *    obviously fine — and says nothing about the cycle that made it throw.
-*  - **CJS interop.** The half-initialised module object has no `default` yet,
-*    the import resolves to `undefined`, and the thunk returns it without
-*    complaint. That one used to surface here as "did not resolve to a
+*  - **CJS interop, unresolved.** The half-initialised module object has no
+*    `default` yet, the import resolves to `undefined`, and the thunk returns it
+*    without complaint. That one used to surface here as "did not resolve to a
 *    collection", which is true and unhelpful.
 *
 * Both mean the same thing, and the fix for both is the same: break the cycle,
 * or move the relation into the collection that does not close it.
+*
+* A third shape is *not* an error, and used to be reported as one. A loader that
+* transpiles ESM to CJS — jiti, which is what `rebase generate-sdk` and
+* `rebase build` load collections with — gives the module entered second in a
+* cycle a namespace object rather than the default export, and never replaces it
+* with a live binding. The thunk then returns `{ __esModule: true, default: … }`
+* holding the fully-initialised collection. Native ESM resolves the same thunk
+* to the collection directly, so this was a loader artefact reported as an
+* authoring mistake, and the advice it gave — make the target a lazy thunk — was
+* already satisfied by the code it was rejecting. Bidirectional relations make
+* these cycles unavoidable, and the lazy thunk is this framework's own answer to
+* them, so {@link unwrapModuleNamespace} takes the collection and moves on.
 */
 function callTarget(relation, sourceCollection, propertyKey, target) {
 	let targetCollection;
 	try {
-		targetCollection = target();
+		targetCollection = unwrapModuleNamespace(target());
 	} catch (error) {
 		if (error instanceof ReferenceError) throw new Error(`${describe(relation, sourceCollection, propertyKey)} targets a collection that is not initialized yet — almost always an import cycle between the two collection files. Break the cycle (move the shared piece into a third module, or import the target lazily) so the target's module finishes evaluating before the registry is built.`, { cause: error });
 		throw error;
 	}
-	if (!targetCollection?.slug) throw new Error(`${describe(relation, sourceCollection, propertyKey)} has a \`target\` that resolved to ${targetCollection === void 0 ? "`undefined`" : "something that is not a collection"}. ` + (targetCollection === void 0 ? "Under CommonJS interop an import cycle resolves the default import to `undefined`, so check whether this collection and its target import each other. Otherwise the thunk is returning the wrong value — it must return the collection itself, not a promise or a module." : "The thunk must return a collection config with a `slug`."));
+	if (!targetCollection?.slug) throw new Error(`${describe(relation, sourceCollection, propertyKey)} has a \`target\` that resolved to ${targetCollection === void 0 ? "`undefined`" : "something that is not a collection"}. ` + (targetCollection === void 0 ? "Under CommonJS interop an import cycle resolves the default import to `undefined`, so check whether this collection and its target import each other. Otherwise the thunk is returning the wrong value — it must return the collection itself, not a promise or a module." : typeof targetCollection.then === "function" ? "The thunk returned a promise — `target: () => import(\"./other\")` is asynchronous. Import the collection at the top of the file and return the binding: `target: () => otherCollection`." : "The thunk must return a collection config with a `slug`."));
 	return targetCollection;
 }
 //#endregion
@@ -2786,6 +2818,7 @@ var REBASE_INTERNAL_TABLES = [
 	"api_keys",
 	"cron_logs",
 	"cron_claims",
+	"rate_limit_hits",
 	"idempotency_keys",
 	"entity_history",
 	"branches",
@@ -3303,6 +3336,13 @@ var defaultUsersCollection = defineCollection({
 * the same value; the two are told apart by whether the first element is
 * itself an array, which no field name ever is.
 *
+* This is also where a {@link RelationAggregateSort} object stops being an
+* object. Above this function a sort key may be either spelling; below it,
+* every key is a string — which is what `OrderByTuple`, the REST parameter, the
+* driver contract and the cursor all already were. Doing it here means the one
+* place that already collapses the two *shapes* of a sort also collapses the
+* two *spellings* of a key, rather than every consumer learning about both.
+*
 * @returns The keys in order of significance, or `undefined` for no sort. An
 *   empty list also returns `undefined` — "sort by nothing" is no sort, and
 *   letting `[]` through would have every layer below re-deciding what it meant.
@@ -3310,7 +3350,8 @@ var defaultUsersCollection = defineCollection({
 function normalizeOrderBy(orderBy) {
 	if (!orderBy || orderBy.length === 0) return void 0;
 	const list = Array.isArray(orderBy[0]) ? orderBy : [orderBy];
-	return list.length > 0 ? list : void 0;
+	if (list.length === 0) return void 0;
+	return list.map(([key, direction]) => [sortKeyToString(key), direction]);
 }
 /**
 * The most significant sort key, for a caller that can only express one —
@@ -3365,14 +3406,16 @@ function parseOrderBySpecStrict(raw, order) {
 	if (raw === void 0 || raw === null || raw === "") return void 0;
 	if (typeof raw === "string") return normalizeDriverOrderBy(raw, order);
 	if (!Array.isArray(raw) || raw.length === 0) throw new OrderBySpecError(`${typeof raw} is not a field name or a list of sort keys`);
-	if (typeof raw[0] === "string") return [toStrictTuple(raw, 0)];
+	if (typeof raw[0] === "string" || isRelationAggregateSort(raw[0])) return [toStrictTuple(raw, 0)];
 	return raw.map(toStrictTuple);
 }
 function toStrictTuple(raw, index) {
-	if (!Array.isArray(raw) || typeof raw[0] !== "string" || raw[0].trim() === "") throw new OrderBySpecError(`entry ${index} has no field name`);
+	if (!Array.isArray(raw)) throw new OrderBySpecError(`entry ${index} has no field name`);
+	const key = isRelationAggregateSort(raw[0]) ? sortKeyToString(raw[0]) : raw[0];
+	if (typeof key !== "string" || key.trim() === "") throw new OrderBySpecError(`entry ${index} has no field name`);
 	const direction = raw[1];
 	if (direction !== void 0 && direction !== "asc" && direction !== "desc") throw new OrderBySpecError(`entry ${index} has direction '${String(direction)}'`);
-	return [raw[0], direction ?? "asc"];
+	return [key, direction ?? "asc"];
 }
 /**
 * Serialize a sort to the wire.