@payloadcms/drizzle 4.0.0-internal.b6f3b9a → 4.0.0-internal.b8a92d2

package/dist/find/createPolymorphicJoinWherePlan.d.ts

@@ -0,0 +1,37 @@
+import { type FlattenedField, type Where } from 'payload';
+import type { DrizzleAdapter } from '../types.js';
+export type ScalarWhereField = {
+    field: FlattenedField;
+    isUUID: boolean;
+    type: 'scalar';
+};
+type CollectionWhereField = {
+    field: FlattenedField;
+    type: 'hasManySelect';
+} | ScalarWhereField;
+export type WherePathPlan = {
+    columnPath: string;
+    fieldsByCollection: Map<string, CollectionWhereField>;
+    schemaPath: string;
+    type: 'hasManySelect' | 'invalid' | 'scalar';
+};
+export type PolymorphicJoinWherePlan = Map<string, WherePathPlan>;
+/**
+ * Analyzes every leaf path in a polymorphic join where clause before SQL is built. Each plan entry
+ * records the flattened column path, the compatible field shape for each target collection, and
+ * whether the path uses a scalar column or a has-many select value table. A field may be absent
+ * from some target collections; those branches compare against SQL NULL or an empty JSON array.
+ *
+ * Paths are marked as invalid when their storage shapes conflict, require localized or separate-row
+ * traversal, have no matching field, lack a required column, or collide after path flattening.
+ *
+ * @returns A plan keyed by each unique schema path in `where`.
+ * @throws If a target collection or its mapped database table is not available in the adapter.
+ */
+export declare const createPolymorphicJoinWherePlan: ({ adapter, collections, where, }: {
+    adapter: DrizzleAdapter;
+    collections: string[];
+    where: Where;
+}) => PolymorphicJoinWherePlan;
+export {};
+//# sourceMappingURL=createPolymorphicJoinWherePlan.d.ts.map

package/dist/find/createPolymorphicJoinWherePlan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createPolymorphicJoinWherePlan.d.ts","sourceRoot":"","sources":["../../src/find/createPolymorphicJoinWherePlan.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,cAAc,EAAkB,KAAK,KAAK,EAAE,MAAM,SAAS,CAAA;AAGzE,OAAO,KAAK,EAAE,cAAc,EAAgB,MAAM,aAAa,CAAA;AAK/D,MAAM,MAAM,gBAAgB,GAAG;IAC7B,KAAK,EAAE,cAAc,CAAA;IACrB,MAAM,EAAE,OAAO,CAAA;IACf,IAAI,EAAE,QAAQ,CAAA;CACf,CAAA;AAED,KAAK,oBAAoB,GAAG;IAAE,KAAK,EAAE,cAAc,CAAC;IAAC,IAAI,EAAE,eAAe,CAAA;CAAE,GAAG,gBAAgB,CAAA;AAE/F,MAAM,MAAM,aAAa,GAAG;IAC1B,UAAU,EAAE,MAAM,CAAA;IAClB,kBAAkB,EAAE,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAA;IACrD,UAAU,EAAE,MAAM,CAAA;IAClB,IAAI,EAAE,eAAe,GAAG,SAAS,GAAG,QAAQ,CAAA;CAC7C,CAAA;AAED,MAAM,MAAM,wBAAwB,GAAG,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;AAEjE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,8BAA8B,qCAIxC;IACD,OAAO,EAAE,cAAc,CAAA;IACvB,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,KAAK,EAAE,KAAK,CAAA;CACb,KAAG,wBAoIH,CAAA"}

package/dist/find/createPolymorphicJoinWherePlan.js

@@ -0,0 +1,191 @@
+import { getFieldByPath } from 'payload';
+import toSnakeCase from 'to-snake-case';
+import { isUUIDType } from '../utilities/isUUIDType.js';
+import { sanitizePathSegment } from '../utilities/sanitizePathSegment.js';
+/**
+ * Analyzes every leaf path in a polymorphic join where clause before SQL is built. Each plan entry
+ * records the flattened column path, the compatible field shape for each target collection, and
+ * whether the path uses a scalar column or a has-many select value table. A field may be absent
+ * from some target collections; those branches compare against SQL NULL or an empty JSON array.
+ *
+ * Paths are marked as invalid when their storage shapes conflict, require localized or separate-row
+ * traversal, have no matching field, lack a required column, or collide after path flattening.
+ *
+ * @returns A plan keyed by each unique schema path in `where`.
+ * @throws If a target collection or its mapped database table is not available in the adapter.
+ */ export const createPolymorphicJoinWherePlan = ({ adapter, collections, where })=>{
+    const collectionContexts = collections.map((collection)=>{
+        const collectionConfig = adapter.payload.collections[collection]?.config;
+        if (!collectionConfig) {
+            throw new Error(`Unknown polymorphic join collection "${collection}"`);
+        }
+        const tableName = adapter.tableNameMap.get(toSnakeCase(collection));
+        const table = tableName ? adapter.tables[tableName] : undefined;
+        if (!table) {
+            throw new Error(`Polymorphic join collection "${collection}" has no database table`);
+        }
+        return {
+            collection,
+            collectionConfig,
+            table
+        };
+    });
+    const schemaPathsByColumnPath = new Map();
+    const schemaPaths = new Set(getWhereSchemaPaths(where));
+    for (const schemaPath of schemaPaths){
+        const columnPath = getColumnPath(schemaPath);
+        const paths = schemaPathsByColumnPath.get(columnPath) ?? new Set();
+        paths.add(schemaPath);
+        schemaPathsByColumnPath.set(columnPath, paths);
+    }
+    const plan = new Map();
+    for (const schemaPath of schemaPaths){
+        const columnPath = getColumnPath(schemaPath);
+        const fieldsByCollection = new Map();
+        let isFieldPresent = schemaPath === 'id' || schemaPath === 'relationTo';
+        let hasManySelect = false;
+        let hasUnsupportedFieldShape = false;
+        const scalarQueryValueSignatures = new Set();
+        for (const { collection, collectionConfig, table } of collectionContexts){
+            const fieldAtPath = getFieldByPath({
+                fields: collectionConfig.flattenedFields,
+                path: schemaPath
+            });
+            if (schemaPath === 'id') {
+                const idColumn = table['id'];
+                if (!idColumn) {
+                    hasUnsupportedFieldShape = true;
+                } else {
+                    scalarQueryValueSignatures.add(`id:${idColumn.getSQLType()}`);
+                    fieldsByCollection.set(collection, {
+                        type: 'scalar',
+                        field: fieldAtPath?.field ?? {
+                            name: 'id',
+                            type: isUUIDType(adapter.idType) ? 'text' : 'number'
+                        },
+                        isUUID: !fieldAtPath && isUUIDType(adapter.idType)
+                    });
+                }
+                continue;
+            }
+            if (!fieldAtPath) {
+                if (pathHasUnsupportedNestedContainer({
+                    fields: collectionConfig.flattenedFields,
+                    path: schemaPath
+                })) {
+                    hasUnsupportedFieldShape = true;
+                }
+                continue;
+            }
+            isFieldPresent = true;
+            if (fieldAtPath.pathHasLocalized || pathHasSeparateRows({
+                fields: collectionConfig.flattenedFields,
+                path: schemaPath
+            })) {
+                hasUnsupportedFieldShape = true;
+                continue;
+            }
+            if (fieldAtPath.field.type === 'select' && fieldAtPath.field.hasMany) {
+                hasManySelect = true;
+                fieldsByCollection.set(collection, {
+                    type: 'hasManySelect',
+                    field: fieldAtPath.field
+                });
+                continue;
+            }
+            const fieldColumn = table[columnPath];
+            if (!fieldColumn) {
+                hasUnsupportedFieldShape = true;
+                continue;
+            }
+            fieldsByCollection.set(collection, {
+                type: 'scalar',
+                field: fieldAtPath.field,
+                isUUID: fieldColumn.columnType === 'PgUUID'
+            });
+            scalarQueryValueSignatures.add(getScalarQueryValueSignature({
+                column: fieldColumn,
+                field: fieldAtPath.field
+            }));
+        }
+        const hasColumnPathCollision = (schemaPathsByColumnPath.get(columnPath)?.size ?? 0) > 1;
+        const isInvalid = hasColumnPathCollision || !isFieldPresent || hasUnsupportedFieldShape || hasManySelect && scalarQueryValueSignatures.size > 0 || scalarQueryValueSignatures.size > 1;
+        plan.set(schemaPath, {
+            type: isInvalid ? 'invalid' : hasManySelect ? 'hasManySelect' : 'scalar',
+            columnPath,
+            fieldsByCollection,
+            schemaPath
+        });
+    }
+    return plan;
+};
+const textQueryFieldTypes = new Set([
+    'code',
+    'email',
+    'slug',
+    'text',
+    'textarea'
+]);
+const getScalarQueryValueSignature = ({ column, field })=>{
+    if (field.type === 'select' || field.type === 'radio') {
+        const optionValues = field.options.map((option)=>typeof option === 'string' ? option : option.value);
+        return `${field.type}:${JSON.stringify(optionValues)}`;
+    }
+    if (textQueryFieldTypes.has(field.type)) {
+        return 'text';
+    }
+    return `${field.type}:${column.getSQLType()}`;
+};
+const getWhereSchemaPaths = (where)=>{
+    const paths = [];
+    for(const key in where){
+        if ([
+            'AND',
+            'OR'
+        ].includes(key.toUpperCase())) {
+            if (Array.isArray(where[key])) {
+                for (const nestedWhere of where[key]){
+                    paths.push(...getWhereSchemaPaths(nestedWhere));
+                }
+            }
+        } else {
+            paths.push(key);
+        }
+    }
+    return paths;
+};
+const getColumnPath = (schemaPath)=>schemaPath.split('.').map((segment)=>sanitizePathSegment(segment)).join('_');
+const pathHasSeparateRows = ({ fields, path })=>{
+    const pathSegments = path.split('.');
+    for(let segmentIndex = 1; segmentIndex < pathSegments.length; segmentIndex++){
+        const fieldAtParentPath = getFieldByPath({
+            fields,
+            path: pathSegments.slice(0, segmentIndex).join('.')
+        });
+        if (fieldAtParentPath?.field.type === 'array' || fieldAtParentPath?.field.type === 'blocks') {
+            return true;
+        }
+    }
+    return false;
+};
+const pathHasUnsupportedNestedContainer = ({ fields, path })=>{
+    const pathSegments = path.split('.');
+    for(let segmentIndex = 1; segmentIndex < pathSegments.length; segmentIndex++){
+        const fieldAtParentPath = getFieldByPath({
+            fields,
+            path: pathSegments.slice(0, segmentIndex).join('.')
+        });
+        if (!fieldAtParentPath) {
+            return false;
+        }
+        if (![
+            'group',
+            'tab'
+        ].includes(fieldAtParentPath.field.type)) {
+            return true;
+        }
+    }
+    return false;
+};
+
+//# sourceMappingURL=createPolymorphicJoinWherePlan.js.map

package/dist/find/createPolymorphicJoinWherePlan.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/find/createPolymorphicJoinWherePlan.ts"],"sourcesContent":["import type { Column } from 'drizzle-orm'\n\nimport { type FlattenedField, getFieldByPath, type Where } from 'payload'\nimport toSnakeCase from 'to-snake-case'\n\nimport type { DrizzleAdapter, GenericTable } from '../types.js'\n\nimport { isUUIDType } from '../utilities/isUUIDType.js'\nimport { sanitizePathSegment } from '../utilities/sanitizePathSegment.js'\n\nexport type ScalarWhereField = {\n  field: FlattenedField\n  isUUID: boolean\n  type: 'scalar'\n}\n\ntype CollectionWhereField = { field: FlattenedField; type: 'hasManySelect' } | ScalarWhereField\n\nexport type WherePathPlan = {\n  columnPath: string\n  fieldsByCollection: Map<string, CollectionWhereField>\n  schemaPath: string\n  type: 'hasManySelect' | 'invalid' | 'scalar'\n}\n\nexport type PolymorphicJoinWherePlan = Map<string, WherePathPlan>\n\n/**\n * Analyzes every leaf path in a polymorphic join where clause before SQL is built. Each plan entry\n * records the flattened column path, the compatible field shape for each target collection, and\n * whether the path uses a scalar column or a has-many select value table. A field may be absent\n * from some target collections; those branches compare against SQL NULL or an empty JSON array.\n *\n * Paths are marked as invalid when their storage shapes conflict, require localized or separate-row\n * traversal, have no matching field, lack a required column, or collide after path flattening.\n *\n * @returns A plan keyed by each unique schema path in `where`.\n * @throws If a target collection or its mapped database table is not available in the adapter.\n */\nexport const createPolymorphicJoinWherePlan = ({\n  adapter,\n  collections,\n  where,\n}: {\n  adapter: DrizzleAdapter\n  collections: string[]\n  where: Where\n}): PolymorphicJoinWherePlan => {\n  const collectionContexts = collections.map((collection) => {\n    const collectionConfig = adapter.payload.collections[collection]?.config\n\n    if (!collectionConfig) {\n      throw new Error(`Unknown polymorphic join collection \"${collection}\"`)\n    }\n\n    const tableName = adapter.tableNameMap.get(toSnakeCase(collection))\n    const table = tableName ? (adapter.tables[tableName] as GenericTable | undefined) : undefined\n\n    if (!table) {\n      throw new Error(`Polymorphic join collection \"${collection}\" has no database table`)\n    }\n\n    return { collection, collectionConfig, table }\n  })\n  const schemaPathsByColumnPath = new Map<string, Set<string>>()\n  const schemaPaths = new Set(getWhereSchemaPaths(where))\n\n  for (const schemaPath of schemaPaths) {\n    const columnPath = getColumnPath(schemaPath)\n    const paths = schemaPathsByColumnPath.get(columnPath) ?? new Set<string>()\n\n    paths.add(schemaPath)\n    schemaPathsByColumnPath.set(columnPath, paths)\n  }\n\n  const plan: PolymorphicJoinWherePlan = new Map()\n\n  for (const schemaPath of schemaPaths) {\n    const columnPath = getColumnPath(schemaPath)\n    const fieldsByCollection = new Map<string, CollectionWhereField>()\n    let isFieldPresent = schemaPath === 'id' || schemaPath === 'relationTo'\n    let hasManySelect = false\n    let hasUnsupportedFieldShape = false\n    const scalarQueryValueSignatures = new Set<string>()\n\n    for (const { collection, collectionConfig, table } of collectionContexts) {\n      const fieldAtPath = getFieldByPath({\n        fields: collectionConfig.flattenedFields,\n        path: schemaPath,\n      })\n\n      if (schemaPath === 'id') {\n        const idColumn = table['id'] as Column | undefined\n\n        if (!idColumn) {\n          hasUnsupportedFieldShape = true\n        } else {\n          scalarQueryValueSignatures.add(`id:${idColumn.getSQLType()}`)\n          fieldsByCollection.set(collection, {\n            type: 'scalar',\n            field:\n              fieldAtPath?.field ??\n              ({\n                name: 'id',\n                type: isUUIDType(adapter.idType) ? 'text' : 'number',\n              } as FlattenedField),\n            isUUID: !fieldAtPath && isUUIDType(adapter.idType),\n          })\n        }\n\n        continue\n      }\n\n      if (!fieldAtPath) {\n        if (\n          pathHasUnsupportedNestedContainer({\n            fields: collectionConfig.flattenedFields,\n            path: schemaPath,\n          })\n        ) {\n          hasUnsupportedFieldShape = true\n        }\n\n        continue\n      }\n\n      isFieldPresent = true\n\n      if (\n        fieldAtPath.pathHasLocalized ||\n        pathHasSeparateRows({ fields: collectionConfig.flattenedFields, path: schemaPath })\n      ) {\n        hasUnsupportedFieldShape = true\n        continue\n      }\n\n      if (fieldAtPath.field.type === 'select' && fieldAtPath.field.hasMany) {\n        hasManySelect = true\n        fieldsByCollection.set(collection, {\n          type: 'hasManySelect',\n          field: fieldAtPath.field,\n        })\n        continue\n      }\n\n      const fieldColumn = table[columnPath] as Column | undefined\n\n      if (!fieldColumn) {\n        hasUnsupportedFieldShape = true\n        continue\n      }\n\n      fieldsByCollection.set(collection, {\n        type: 'scalar',\n        field: fieldAtPath.field,\n        isUUID: fieldColumn.columnType === 'PgUUID',\n      })\n      scalarQueryValueSignatures.add(\n        getScalarQueryValueSignature({ column: fieldColumn, field: fieldAtPath.field }),\n      )\n    }\n\n    const hasColumnPathCollision = (schemaPathsByColumnPath.get(columnPath)?.size ?? 0) > 1\n    const isInvalid =\n      hasColumnPathCollision ||\n      !isFieldPresent ||\n      hasUnsupportedFieldShape ||\n      (hasManySelect && scalarQueryValueSignatures.size > 0) ||\n      scalarQueryValueSignatures.size > 1\n\n    plan.set(schemaPath, {\n      type: isInvalid ? 'invalid' : hasManySelect ? 'hasManySelect' : 'scalar',\n      columnPath,\n      fieldsByCollection,\n      schemaPath,\n    })\n  }\n\n  return plan\n}\n\nconst textQueryFieldTypes = new Set<FlattenedField['type']>([\n  'code',\n  'email',\n  'slug',\n  'text',\n  'textarea',\n])\n\nconst getScalarQueryValueSignature = ({\n  column,\n  field,\n}: {\n  column: Column\n  field: FlattenedField\n}): string => {\n  if (field.type === 'select' || field.type === 'radio') {\n    const optionValues = field.options.map((option) =>\n      typeof option === 'string' ? option : option.value,\n    )\n\n    return `${field.type}:${JSON.stringify(optionValues)}`\n  }\n\n  if (textQueryFieldTypes.has(field.type)) {\n    return 'text'\n  }\n\n  return `${field.type}:${column.getSQLType()}`\n}\n\nconst getWhereSchemaPaths = (where: Where): string[] => {\n  const paths: string[] = []\n\n  for (const key in where) {\n    if (['AND', 'OR'].includes(key.toUpperCase())) {\n      if (Array.isArray(where[key])) {\n        for (const nestedWhere of where[key]) {\n          paths.push(...getWhereSchemaPaths(nestedWhere))\n        }\n      }\n    } else {\n      paths.push(key)\n    }\n  }\n\n  return paths\n}\n\nconst getColumnPath = (schemaPath: string): string =>\n  schemaPath\n    .split('.')\n    .map((segment) => sanitizePathSegment(segment))\n    .join('_')\n\nconst pathHasSeparateRows = ({ fields, path }: { fields: FlattenedField[]; path: string }) => {\n  const pathSegments = path.split('.')\n\n  for (let segmentIndex = 1; segmentIndex < pathSegments.length; segmentIndex++) {\n    const fieldAtParentPath = getFieldByPath({\n      fields,\n      path: pathSegments.slice(0, segmentIndex).join('.'),\n    })\n\n    if (fieldAtParentPath?.field.type === 'array' || fieldAtParentPath?.field.type === 'blocks') {\n      return true\n    }\n  }\n\n  return false\n}\n\nconst pathHasUnsupportedNestedContainer = ({\n  fields,\n  path,\n}: {\n  fields: FlattenedField[]\n  path: string\n}) => {\n  const pathSegments = path.split('.')\n\n  for (let segmentIndex = 1; segmentIndex < pathSegments.length; segmentIndex++) {\n    const fieldAtParentPath = getFieldByPath({\n      fields,\n      path: pathSegments.slice(0, segmentIndex).join('.'),\n    })\n\n    if (!fieldAtParentPath) {\n      return false\n    }\n\n    if (!['group', 'tab'].includes(fieldAtParentPath.field.type)) {\n      return true\n    }\n  }\n\n  return false\n}\n"],"names":["getFieldByPath","toSnakeCase","isUUIDType","sanitizePathSegment","createPolymorphicJoinWherePlan","adapter","collections","where","collectionContexts","map","collection","collectionConfig","payload","config","Error","tableName","tableNameMap","get","table","tables","undefined","schemaPathsByColumnPath","Map","schemaPaths","Set","getWhereSchemaPaths","schemaPath","columnPath","getColumnPath","paths","add","set","plan","fieldsByCollection","isFieldPresent","hasManySelect","hasUnsupportedFieldShape","scalarQueryValueSignatures","fieldAtPath","fields","flattenedFields","path","idColumn","getSQLType","type","field","name","idType","isUUID","pathHasUnsupportedNestedContainer","pathHasLocalized","pathHasSeparateRows","hasMany","fieldColumn","columnType","getScalarQueryValueSignature","column","hasColumnPathCollision","size","isInvalid","textQueryFieldTypes","optionValues","options","option","value","JSON","stringify","has","key","includes","toUpperCase","Array","isArray","nestedWhere","push","split","segment","join","pathSegments","segmentIndex","length","fieldAtParentPath","slice"],"mappings":"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"}

package/dist/find/traverseFields.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"traverseFields.d.ts","sourceRoot":"","sources":["../../src/find/traverseFields.ts"],"names":[],"mappings":"AAIA,OAAO,EAIL,KAAK,cAAc,EAGnB,KAAK,SAAS,EACd,KAAK,UAAU,EACf,KAAK,UAAU,EAEhB,MAAM,SAAS,CAAA;AAIhB,OAAO,KAAK,EAAE,qBAAqB,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AACxE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AA6EpD,KAAK,iBAAiB,GAAG;IACvB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,cAAc,CAAA;IACvB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,WAAW,EAAE,MAAM,CAAA;IACnB,gBAAgB,EAAE,MAAM,CAAA;IACxB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,MAAM,EAAE,cAAc,EAAE,CAAA;IACxB,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,SAAS,EAAE,SAAS,CAAA;IACpB,KAAK,CAAC,EAAE,qBAAqB,CAAA;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,CAAC,EAAE,UAAU,CAAA;IACnB,uBAAuB,CAAC,EAAE,OAAO,CAAA;IACjC,UAAU,CAAC,EAAE,UAAU,CAAA;IACvB,SAAS,EAAE,MAAM,CAAA;IACjB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACrC,iBAAiB,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,gBAAgB,EAAE;QAChB,OAAO,CAAC,EAAE,OAAO,CAAA;QACjB,IAAI,CAAC,EAAE,OAAO,CAAA;QACd,KAAK,CAAC,EAAE,OAAO,CAAA;KAChB,CAAA;CACF,CAAA;AAED,eAAO,MAAM,cAAc,iSAuBxB,iBAAiB,4BAkyBnB,CAAA"}
+{"version":3,"file":"traverseFields.d.ts","sourceRoot":"","sources":["../../src/find/traverseFields.ts"],"names":[],"mappings":"AAIA,OAAO,EAIL,KAAK,cAAc,EAEnB,KAAK,SAAS,EACd,KAAK,UAAU,EACf,KAAK,UAAU,EAEhB,MAAM,SAAS,CAAA;AAIhB,OAAO,KAAK,EAAE,qBAAqB,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AACxE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAA;AAcpD,KAAK,iBAAiB,GAAG;IACvB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,cAAc,CAAA;IACvB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,WAAW,EAAE,MAAM,CAAA;IACnB,gBAAgB,EAAE,MAAM,CAAA;IACxB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,MAAM,EAAE,cAAc,EAAE,CAAA;IACxB,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,SAAS,EAAE,SAAS,CAAA;IACpB,KAAK,CAAC,EAAE,qBAAqB,CAAA;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,iBAAiB,CAAC,EAAE,OAAO,CAAA;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,CAAC,EAAE,UAAU,CAAA;IACnB,uBAAuB,CAAC,EAAE,OAAO,CAAA;IACjC,UAAU,CAAC,EAAE,UAAU,CAAA;IACvB,SAAS,EAAE,MAAM,CAAA;IACjB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACrC,iBAAiB,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,gBAAgB,EAAE;QAChB,OAAO,CAAC,EAAE,OAAO,CAAA;QACjB,IAAI,CAAC,EAAE,OAAO,CAAA;QACd,KAAK,CAAC,EAAE,OAAO,CAAA;KAChB,CAAA;CACF,CAAA;AAED,eAAO,MAAM,cAAc,iSAuBxB,iBAAiB,4BA0oBnB,CAAA"}

package/dist/find/traverseFields.js

@@ -1,74 +1,15 @@
-import { and, asc, count, desc, eq, getTableName, or, sql } from 'drizzle-orm';
-import { appendVersionToQueryKey, buildVersionCollectionFields, combineQueries, getFieldByPath, getQueryDraftsSort } from 'payload';
+import { count, sql } from 'drizzle-orm';
+import { appendVersionToQueryKey, buildVersionCollectionFields, combineQueries, getQueryDraftsSort } from 'payload';
 import { fieldIsVirtual, fieldShouldBeLocalized, hasDraftsEnabled } from 'payload/shared';
 import toSnakeCase from 'to-snake-case';
 import { buildQuery } from '../queries/buildQuery.js';
 import { getTableAlias } from '../queries/getTableAlias.js';
-import { operatorMap } from '../queries/operatorMap.js';
 import { getArrayRelationName } from '../utilities/getArrayRelationName.js';
 import { getNameFromDrizzleTable } from '../utilities/getNameFromDrizzleTable.js';
 import { jsonAggBuildObject } from '../utilities/json.js';
 import { rawConstraint } from '../utilities/rawConstraint.js';
-import { sanitizePathSegment } from '../utilities/sanitizePathSegment.js';
 import { InternalBlockTableNameIndex, resolveBlockTableName } from '../utilities/validateExistingBlockIsIdentical.js';
-const flattenAllWherePaths = (where, paths)=>{
-    for(const k in where){
-        if ([
-            'AND',
-            'OR'
-        ].includes(k.toUpperCase())) {
-            if (Array.isArray(where[k])) {
-                for (const whereField of where[k]){
-                    flattenAllWherePaths(whereField, paths);
-                }
-            }
-        } else {
-            // TODO: explore how to support arrays/relationship querying.
-            paths.push({
-                path: k.split('.').join('_'),
-                ref: where
-            });
-        }
-    }
-};
-const buildSQLWhere = (where, alias)=>{
-    for(const k in where){
-        if ([
-            'AND',
-            'OR'
-        ].includes(k.toUpperCase())) {
-            if (Array.isArray(where[k])) {
-                const op = 'AND' === k.toUpperCase() ? and : or;
-                const accumulated = [];
-                for (const whereField of where[k]){
-                    accumulated.push(buildSQLWhere(whereField, alias));
-                }
-                return op(...accumulated);
-            }
-        } else {
-            let payloadOperator = Object.keys(where[k])[0];
-            const value = where[k][payloadOperator];
-            if (payloadOperator === '$raw') {
-                if (typeof value !== 'string') {
-                    return undefined;
-                }
-                return sql.raw(value);
-            }
-            // Handle exists: false -> use isNull instead of isNotNull
-            // This logic is duplicated from sanitizeQueryValue.ts because buildSQLWhere
-            // is a simplified WHERE builder for polymorphic joins that doesn't have access
-            // to field definitions needed by sanitizeQueryValue
-            if (payloadOperator === 'exists' && value === false) {
-                payloadOperator = 'isNull';
-            }
-            if (!(payloadOperator in operatorMap)) {
-                return undefined;
-            }
-            const sanitizedColumnName = k.split('.').map((s)=>sanitizePathSegment(s)).join('_');
-            return operatorMap[payloadOperator](sql.raw(`"${alias}"."${sanitizedColumnName}"`), value);
-        }
-    }
-};
+import { buildPolymorphicJoinQuery } from './buildPolymorphicJoinQuery.js';
 export const traverseFields = ({ _locales, adapter, collectionSlug, currentArgs, currentTableName, depth, draftsEnabled, fields, forceWithFields, joinQuery = {}, joins, locale, parentIsLocalized = false, path, select, selectAllOnCurrentLevel = false, selectMode, tablePath, topLevelArgs, topLevelTableName, versions, withTabledFields })=>{
     fields.forEach((field)=>{
         if (fieldIsVirtual(field)) {
@@ -309,138 +250,25 @@ export const traverseFields = ({ _locales, adapter, collectionSlug, currentArgs,
                         // get an additional document and slice it later to determine if there is a next page
                         limit += 1;
                     }
-                    const columnName = `${path.replaceAll('.', '_')}${field.name}`;
-                    const db = adapter.drizzle;
                     if (Array.isArray(field.collection)) {
-                        let currentQuery = null;
-                        const onPath = field.on.split('.').join('_');
-                        if (Array.isArray(sort)) {
-                            throw new Error('Not implemented');
-                        }
-                        let sanitizedSort = sort;
-                        if (!sanitizedSort) {
-                            if (field.collection.some((collection)=>adapter.payload.collections[collection].config.fields.some((f)=>f.type === 'date' && f.name === 'createdAt'))) {
-                                sanitizedSort = '-createdAt';
-                            } else {
-                                sanitizedSort = 'id';
-                            }
-                        }
-                        const sortOrder = sanitizedSort.startsWith('-') ? desc : asc;
-                        sanitizedSort = sanitizedSort.replace('-', '');
-                        const sortPath = sanitizedSort.split('.').join('_');
-                        const wherePaths = [];
-                        if (where) {
-                            flattenAllWherePaths(where, wherePaths);
-                        }
-                        for (const collection of field.collection){
-                            const joinCollectionTableName = adapter.tableNameMap.get(toSnakeCase(collection));
-                            const table = adapter.tables[joinCollectionTableName];
-                            const sortColumn = table[sortPath];
-                            const selectFields = {
-                                id: adapter.tables[joinCollectionTableName].id,
-                                parent: sql`${adapter.tables[joinCollectionTableName][onPath]}`.as(onPath),
-                                relationTo: sql`${collection}`.as('relationTo'),
-                                sortPath: sql`${sortColumn ? sortColumn : null}`.as('sortPath')
-                            };
-                            const collectionQueryWhere = [];
-                            // Select for WHERE and Fallback NULL
-                            for (const { path, ref } of wherePaths){
-                                const collectioConfig = adapter.payload.collections[collection].config;
-                                const field = getFieldByPath({
-                                    fields: collectioConfig.flattenedFields,
-                                    path
-                                });
-                                if (field && field.field.type === 'select' && field.field.hasMany) {
-                                    let tableName = adapter.tableNameMap.get(`${toSnakeCase(collection)}_${toSnakeCase(path)}`);
-                                    let parentTable = getTableName(table);
-                                    if (adapter.schemaName) {
-                                        tableName = `"${adapter.schemaName}"."${tableName}"`;
-                                        parentTable = `"${adapter.schemaName}"."${parentTable}"`;
-                                    }
-                                    if (adapter.name === 'postgres') {
-                                        selectFields[path] = sql.raw(`(select jsonb_agg(${tableName}.value) from ${tableName} where ${tableName}.parent_id = ${parentTable}.id)`).as(path);
-                                    } else {
-                                        selectFields[path] = sql.raw(`(select json_group_array(${tableName}.value) from ${tableName} where ${tableName}.parent_id = ${parentTable}.id)`).as(path);
-                                    }
-                                    const constraint = ref[path];
-                                    const operator = Object.keys(constraint)[0];
-                                    const value = Object.values(constraint)[0];
-                                    const query = adapter.createJSONQuery({
-                                        column: `"${path}"`,
-                                        operator,
-                                        pathSegments: [
-                                            field.field.name
-                                        ],
-                                        table: parentTable,
-                                        value
-                                    });
-                                    ref[path] = {
-                                        $raw: query
-                                    };
-                                } else if (adapter.tables[joinCollectionTableName][path]) {
-                                    selectFields[path] = sql`${adapter.tables[joinCollectionTableName][path]}`.as(path);
-                                // Allow to filter by collectionSlug
-                                } else if (path !== 'relationTo') {
-                                    // For timestamp fields like deletedAt, we need to cast to timestamp in Postgres
-                                    // SQLite doesn't require explicit type casting for UNION queries
-                                    if (path === 'deletedAt' && adapter.name === 'postgres') {
-                                        selectFields[path] = sql`null::timestamp with time zone`.as(path);
-                                    } else {
-                                        selectFields[path] = sql`null`.as(path);
-                                    }
-                                }
-                            }
-                            let query = db.select(selectFields).from(adapter.tables[joinCollectionTableName]);
-                            if (collectionQueryWhere.length) {
-                                query = query.where(and(...collectionQueryWhere));
-                            }
-                            if (currentQuery === null) {
-                                currentQuery = query;
-                            } else {
-                                currentQuery = currentQuery.unionAll(query);
-                            }
-                        }
-                        const subQueryAlias = `${columnName}_subquery`;
-                        let sqlWhere = eq(sql.raw(`"${currentTableName}"."id"`), sql.raw(`"${subQueryAlias}"."${onPath}"`));
-                        if (where && Object.keys(where).length > 0) {
-                            sqlWhere = and(sqlWhere, buildSQLWhere(where, subQueryAlias));
-                        }
-                        if (shouldCount) {
-                            currentArgs.extras[`${columnName}_count`] = sql`${db.select({
-                                count: count()
-                            }).from(sql`${currentQuery.as(subQueryAlias)}`).where(sqlWhere)}`.as(`${columnName}_count`);
-                        }
-                        currentQuery = currentQuery.orderBy(sortOrder(sql`"sortPath"`));
-                        const sortedUnionAlias = `${columnName}_sorted`;
-                        let limitOffsetSQL = sql.empty();
-                        if (limit) {
-                            limitOffsetSQL = sql` LIMIT ${limit}`;
-                        }
-                        if (page && limit !== 0) {
-                            const offset = (page - 1) * limit;
-                            if (offset > 0) {
-                                limitOffsetSQL = sql`${limitOffsetSQL} OFFSET ${offset}`;
-                            }
-                        }
-                        // Correlate to parent row + apply any join where filters
-                        let innerWhere = sql.raw(`"${sortedUnionAlias}"."${onPath}" = "${currentTableName}"."id"`);
-                        if (where && Object.keys(where).length > 0) {
-                            const additionalWhere = buildSQLWhere(where, sortedUnionAlias);
-                            innerWhere = sql`${innerWhere} AND ${additionalWhere}`;
+                        const polymorphicJoinQuery = buildPolymorphicJoinQuery({
+                            adapter,
+                            currentTableName,
+                            field,
+                            limit,
+                            locale,
+                            page,
+                            path,
+                            shouldCount,
+                            sort,
+                            where
+                        });
+                        currentArgs.extras[polymorphicJoinQuery.columnName] = polymorphicJoinQuery.documents;
+                        if (polymorphicJoinQuery.count) {
+                            currentArgs.extras[`${polymorphicJoinQuery.columnName}_count`] = polymorphicJoinQuery.count;
                         }
-                        // IMPORTANT: For polymorphic joins, LIMIT must be applied AFTER correlating to the parent row.
-                        // Otherwise, the limit applies globally across ALL parents, not per-parent.
-                        currentArgs.extras[columnName] = sql`(
-            SELECT ${jsonAggBuildObject(adapter, {
-                            id: sql.raw(`"${subQueryAlias}"."id"`),
-                            relationTo: sql.raw(`"${subQueryAlias}"."relationTo"`)
-                        })}
-            FROM (
-              SELECT * FROM ${sql`${currentQuery.as(sortedUnionAlias)}`}
-              WHERE ${innerWhere}${limitOffsetSQL}
-            ) AS ${sql.raw(`"${subQueryAlias}"`)}
-          )`.as(columnName);
                     } else {
+                        const db = adapter.drizzle;
                         const useDrafts = (versions || draftsEnabled) && hasDraftsEnabled(adapter.payload.collections[field.collection].config);
                         const fields = useDrafts ? buildVersionCollectionFields(adapter.payload.config, adapter.payload.collections[field.collection].config, true) : adapter.payload.collections[field.collection].config.flattenedFields;
                         const joinCollectionTableName = adapter.tableNameMap.get(useDrafts ? `_${toSnakeCase(field.collection)}${adapter.versionsSuffix}` : toSnakeCase(field.collection));