@rebasepro/server-postgres 0.14.1 → 0.14.2-canary.g27a129e

package/dist/{auth-users-columns-C-FDnL_e.js → auth-users-columns-JJ8ngvy5.js}

@@ -3,7 +3,7 @@ import "process";
 __createRequire(import.meta.url);
 import { l as __require, s as __commonJSMin } from "./connection-BuZ97wsr.js";
 import { a as policy, i as ANONYMOUS_USER_IDS, r as ANONYMOUS_USER_ID } from "./data_driver-ULAyJEi9.js";
-import { a as rewriteLegacyRlsFunctions, c as isPostgresCollectionConfig, d as getDataSourceCapabilities, f as ALL_WHERE_FILTER_OPS, g as toCanonicalOp, h as REST_TO_CANONICAL, i as RLS_UID_SQL, l as isRelationalCollectionConfig, m as NULL_OPS, p as CANONICAL_TO_REST, r as RLS_ROLES_SQL, s as getDeclaredSubcollections } from "./src-DCdn3Val.js";
+import { _ as isRelationAggregateSort, a as rewriteLegacyRlsFunctions, b as toCanonicalOp, c as isPostgresCollectionConfig, d as getDataSourceCapabilities, f as ALL_WHERE_FILTER_OPS, h as REST_TO_CANONICAL, i as RLS_UID_SQL, l as isRelationalCollectionConfig, m as NULL_OPS, p as CANONICAL_TO_REST, r as RLS_ROLES_SQL, s as getDeclaredSubcollections, y as sortKeyToString } from "./src-BBFsDaeA.js";
 import { createHash } from "node:crypto";
 //#region ../types/src/types/entities.ts
 /**
@@ -1779,7 +1779,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,
@@ -1847,35 +1847,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
@@ -4026,6 +4058,13 @@ var CollectionRegistry = class {
 * 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.
@@ -4033,7 +4072,8 @@ var CollectionRegistry = class {
 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]);
 }
 /**
 * Collapse the driver-level `{orderBy, order}` pair into the list form.
@@ -4080,14 +4120,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"];
 }
 //#endregion
 //#region ../common/src/data/query_builder.ts
@@ -5662,4 +5704,4 @@ function isAuthCollection(collection) {
 //#endregion
 export { mergeDeep as $, fieldKeyForColumn as A, parseIdValues as B, getJunctionCollectionConfig as C, policyToPostgres as D, getEffectiveSecurityRules as E, getTableVarName as F, updateDateAutoValues as G, createRelationRef as H, resolveCollectionRelations as I, legacyForeignKeyName as J, firstFreeKey as K, buildCompositeId as L, getColumnName as M, getEnumVarName as N, securityRuleToConditions as O, getTableName as P, isPrototypePollutingKey as Q, getDeclaredPrimaryKeys as R, resolveStringColumnLength as S, resolveJunctionSpecs as T, createRelationRefWithData as U, sortCollectionsBySlug as V, normalizeToEntityRelation as W, toWireKey as X, toPostgresIdentifier as Y, getPolicyNamesForRule as Z, OrderBySpecError as _, SEARCH_STAMP_PREFIX as a, isManyToMany as at, CollectionRegistry as b, assertSearchIsPostgresOnly as c, searchColumnStamps as d, camelCase as et, searchExtensionStatements as f, buildSdkData as g, visibleColumnProjection as h, isAuthCollection as i, hasForeignKeyOnTarget as it, findRelation as j, findAnonymousGrants as k, buildSearchColumnSpec as l, searchIndexStatements as m, authUsersColumnDefinition as n, DEFAULT_ONE_OF_TYPE as nt, SEARCH_TEXT_FN as o, Vector as ot, searchHelperFunctions as p, generateForeignKeyName as q, authUsersColumnSql as r, DEFAULT_ONE_OF_VALUE as rt, SEARCH_UNACCENT_FN as s, AUTH_USERS_COLUMNS as t, toSnakeCase as tt, hiddenColumnsOption as u, normalizeDriverOrderBy as v, getJunctionSecurityRules as w, relationalCollections as x, parseOrderBySpecStrict as y, isAddressableId as z };
 
-//# sourceMappingURL=auth-users-columns-C-FDnL_e.js.map
+//# sourceMappingURL=auth-users-columns-JJ8ngvy5.js.map