@payloadcms/drizzle 4.0.0-internal.c7d5de4 → 4.0.0-internal.cc18726

package/dist/queries/validateOperatorHandlers.js

@@ -0,0 +1,30 @@
+import { APIError } from 'payload';
+const isReplacementHandler = (handler)=>typeof handler.build === 'function';
+const fieldTypesOverlap = (a, b)=>!a.fieldTypes || !b.fieldTypes || a.fieldTypes.some((fieldType)=>b.fieldTypes.includes(fieldType));
+/**
+ * Validates operator-handler configuration before any request runs: rejects a handler that
+ * defines both `build` and `transformOperands`, and rejects two replacement handlers whose
+ * `operators` and `fieldTypes` both overlap for the same resolved operator.
+ */ export const validateOperatorHandlers = (operatorHandlers)=>{
+    for (const handler of operatorHandlers){
+        if (typeof handler.build === 'function' && typeof handler.transformOperands === 'function') {
+            throw new APIError(`Operator handler "${handler.name}" cannot define both "build" and "transformOperands". Use "transformOperands" to adjust operands, or "build" to replace the comparison entirely.`);
+        }
+    }
+    const replacementHandlers = operatorHandlers.filter(isReplacementHandler);
+    for(let i = 0; i < replacementHandlers.length; i++){
+        for(let j = i + 1; j < replacementHandlers.length; j++){
+            const handlerA = replacementHandlers[i];
+            const handlerB = replacementHandlers[j];
+            const sharedOperators = handlerA.operators.filter((operator)=>handlerB.operators.includes(operator));
+            if (!sharedOperators.length) {
+                continue;
+            }
+            if (fieldTypesOverlap(handlerA, handlerB)) {
+                throw new APIError(`Operator handlers "${handlerA.name}" and "${handlerB.name}" both replace the "${sharedOperators.join('", "')}" operator for overlapping field types. Only one replacement handler may match a given resolved operator and field type.`);
+            }
+        }
+    }
+};
+
+//# sourceMappingURL=validateOperatorHandlers.js.map

package/dist/queries/validateOperatorHandlers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/queries/validateOperatorHandlers.ts"],"sourcesContent":["import { APIError } from 'payload'\n\nimport type { DrizzleOperatorHandler, DrizzleOperatorReplacementHandler } from '../types.js'\n\nconst isReplacementHandler = (\n  handler: DrizzleOperatorHandler,\n): handler is DrizzleOperatorReplacementHandler => typeof handler.build === 'function'\n\nconst fieldTypesOverlap = (\n  a: DrizzleOperatorReplacementHandler,\n  b: DrizzleOperatorReplacementHandler,\n): boolean =>\n  !a.fieldTypes ||\n  !b.fieldTypes ||\n  a.fieldTypes.some((fieldType) => b.fieldTypes.includes(fieldType))\n\n/**\n * Validates operator-handler configuration before any request runs: rejects a handler that\n * defines both `build` and `transformOperands`, and rejects two replacement handlers whose\n * `operators` and `fieldTypes` both overlap for the same resolved operator.\n */\nexport const validateOperatorHandlers = (operatorHandlers: DrizzleOperatorHandler[]): void => {\n  for (const handler of operatorHandlers) {\n    if (typeof handler.build === 'function' && typeof handler.transformOperands === 'function') {\n      throw new APIError(\n        `Operator handler \"${handler.name}\" cannot define both \"build\" and \"transformOperands\". Use \"transformOperands\" to adjust operands, or \"build\" to replace the comparison entirely.`,\n      )\n    }\n  }\n\n  const replacementHandlers = operatorHandlers.filter(isReplacementHandler)\n\n  for (let i = 0; i < replacementHandlers.length; i++) {\n    for (let j = i + 1; j < replacementHandlers.length; j++) {\n      const handlerA = replacementHandlers[i]\n      const handlerB = replacementHandlers[j]\n\n      const sharedOperators = handlerA.operators.filter((operator) =>\n        handlerB.operators.includes(operator),\n      )\n\n      if (!sharedOperators.length) {\n        continue\n      }\n\n      if (fieldTypesOverlap(handlerA, handlerB)) {\n        throw new APIError(\n          `Operator handlers \"${handlerA.name}\" and \"${handlerB.name}\" both replace the \"${sharedOperators.join('\", \"')}\" operator for overlapping field types. Only one replacement handler may match a given resolved operator and field type.`,\n        )\n      }\n    }\n  }\n}\n"],"names":["APIError","isReplacementHandler","handler","build","fieldTypesOverlap","a","b","fieldTypes","some","fieldType","includes","validateOperatorHandlers","operatorHandlers","transformOperands","name","replacementHandlers","filter","i","length","j","handlerA","handlerB","sharedOperators","operators","operator","join"],"mappings":"AAAA,SAASA,QAAQ,QAAQ,UAAS;AAIlC,MAAMC,uBAAuB,CAC3BC,UACiD,OAAOA,QAAQC,KAAK,KAAK;AAE5E,MAAMC,oBAAoB,CACxBC,GACAC,IAEA,CAACD,EAAEE,UAAU,IACb,CAACD,EAAEC,UAAU,IACbF,EAAEE,UAAU,CAACC,IAAI,CAAC,CAACC,YAAcH,EAAEC,UAAU,CAACG,QAAQ,CAACD;AAEzD;;;;CAIC,GACD,OAAO,MAAME,2BAA2B,CAACC;IACvC,KAAK,MAAMV,WAAWU,iBAAkB;QACtC,IAAI,OAAOV,QAAQC,KAAK,KAAK,cAAc,OAAOD,QAAQW,iBAAiB,KAAK,YAAY;YAC1F,MAAM,IAAIb,SACR,CAAC,kBAAkB,EAAEE,QAAQY,IAAI,CAAC,gJAAgJ,CAAC;QAEvL;IACF;IAEA,MAAMC,sBAAsBH,iBAAiBI,MAAM,CAACf;IAEpD,IAAK,IAAIgB,IAAI,GAAGA,IAAIF,oBAAoBG,MAAM,EAAED,IAAK;QACnD,IAAK,IAAIE,IAAIF,IAAI,GAAGE,IAAIJ,oBAAoBG,MAAM,EAAEC,IAAK;YACvD,MAAMC,WAAWL,mBAAmB,CAACE,EAAE;YACvC,MAAMI,WAAWN,mBAAmB,CAACI,EAAE;YAEvC,MAAMG,kBAAkBF,SAASG,SAAS,CAACP,MAAM,CAAC,CAACQ,WACjDH,SAASE,SAAS,CAACb,QAAQ,CAACc;YAG9B,IAAI,CAACF,gBAAgBJ,MAAM,EAAE;gBAC3B;YACF;YAEA,IAAId,kBAAkBgB,UAAUC,WAAW;gBACzC,MAAM,IAAIrB,SACR,CAAC,mBAAmB,EAAEoB,SAASN,IAAI,CAAC,OAAO,EAAEO,SAASP,IAAI,CAAC,oBAAoB,EAAEQ,gBAAgBG,IAAI,CAAC,QAAQ,wHAAwH,CAAC;YAE3O;QACF;IACF;AACF,EAAC"}

package/dist/queries/validateOperatorHandlers.spec.js

@@ -0,0 +1,142 @@
+import { describe, expect, it } from 'vitest';
+import { validateOperatorHandlers } from './validateOperatorHandlers.js';
+const transformHandler = (overrides = {})=>({
+        name: 'transform',
+        operators: [
+            'contains'
+        ],
+        transformOperands: ({ column, value })=>({
+                column,
+                value
+            }),
+        ...overrides
+    });
+const replacementHandler = (overrides = {})=>({
+        name: 'replace',
+        operators: [
+            'contains'
+        ],
+        build: ()=>null,
+        ...overrides
+    });
+describe('validateOperatorHandlers', ()=>{
+    it('does not throw when zero handlers are configured', ()=>{
+        expect(()=>validateOperatorHandlers([])).not.toThrow();
+    });
+    it('does not throw for any number of non-conflicting operand-transform handlers', ()=>{
+        expect(()=>validateOperatorHandlers([
+                transformHandler({
+                    name: 'a'
+                }),
+                transformHandler({
+                    name: 'b'
+                }),
+                transformHandler({
+                    name: 'c'
+                })
+            ])).not.toThrow();
+    });
+    it('throws when two build handlers list the same resolved operator, naming both handlers and the operator', ()=>{
+        expect(()=>validateOperatorHandlers([
+                replacementHandler({
+                    name: 'handler-a',
+                    operators: [
+                        'contains'
+                    ]
+                }),
+                replacementHandler({
+                    name: 'handler-b',
+                    operators: [
+                        'contains'
+                    ]
+                })
+            ])).toThrow(/handler-a/);
+        expect(()=>validateOperatorHandlers([
+                replacementHandler({
+                    name: 'handler-a',
+                    operators: [
+                        'contains'
+                    ]
+                }),
+                replacementHandler({
+                    name: 'handler-b',
+                    operators: [
+                        'contains'
+                    ]
+                })
+            ])).toThrow(/handler-b/);
+        expect(()=>validateOperatorHandlers([
+                replacementHandler({
+                    name: 'handler-a',
+                    operators: [
+                        'contains'
+                    ]
+                }),
+                replacementHandler({
+                    name: 'handler-b',
+                    operators: [
+                        'contains'
+                    ]
+                })
+            ])).toThrow(/contains/);
+    });
+    it('does not throw when two build handlers target the same operator but declare disjoint fieldTypes', ()=>{
+        expect(()=>validateOperatorHandlers([
+                replacementHandler({
+                    name: 'text',
+                    operators: [
+                        'contains'
+                    ],
+                    fieldTypes: [
+                        'text'
+                    ]
+                }),
+                replacementHandler({
+                    name: 'number',
+                    operators: [
+                        'contains'
+                    ],
+                    fieldTypes: [
+                        'number'
+                    ]
+                })
+            ])).not.toThrow();
+    });
+    it('throws when two build handlers target the same operator and at least one declares no fieldTypes', ()=>{
+        expect(()=>validateOperatorHandlers([
+                replacementHandler({
+                    name: 'unrestricted',
+                    operators: [
+                        'contains'
+                    ]
+                }),
+                replacementHandler({
+                    name: 'text',
+                    operators: [
+                        'contains'
+                    ],
+                    fieldTypes: [
+                        'text'
+                    ]
+                })
+            ])).toThrow();
+    });
+    it('throws when a handler object defines both build and transformOperands', ()=>{
+        const malformed = {
+            name: 'malformed',
+            operators: [
+                'contains'
+            ],
+            build: ()=>null,
+            transformOperands: ({ column, value })=>({
+                    column,
+                    value
+                })
+        };
+        expect(()=>validateOperatorHandlers([
+                malformed
+            ])).toThrow(/malformed/);
+    });
+});
+
+//# sourceMappingURL=validateOperatorHandlers.spec.js.map

package/dist/queries/validateOperatorHandlers.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/queries/validateOperatorHandlers.spec.ts"],"sourcesContent":["import { describe, expect, it } from 'vitest'\n\nimport type { DrizzleOperatorHandler } from '../types.js'\n\nimport { validateOperatorHandlers } from './validateOperatorHandlers.js'\n\nconst transformHandler = (\n  overrides: Partial<DrizzleOperatorHandler> = {},\n): DrizzleOperatorHandler =>\n  ({\n    name: 'transform',\n    operators: ['contains'],\n    transformOperands: ({ column, value }) => ({ column, value }),\n    ...overrides,\n  }) as DrizzleOperatorHandler\n\nconst replacementHandler = (\n  overrides: Partial<DrizzleOperatorHandler> = {},\n): DrizzleOperatorHandler =>\n  ({\n    name: 'replace',\n    operators: ['contains'],\n    build: () => null as any,\n    ...overrides,\n  }) as DrizzleOperatorHandler\n\ndescribe('validateOperatorHandlers', () => {\n  it('does not throw when zero handlers are configured', () => {\n    expect(() => validateOperatorHandlers([])).not.toThrow()\n  })\n\n  it('does not throw for any number of non-conflicting operand-transform handlers', () => {\n    expect(() =>\n      validateOperatorHandlers([\n        transformHandler({ name: 'a' }),\n        transformHandler({ name: 'b' }),\n        transformHandler({ name: 'c' }),\n      ]),\n    ).not.toThrow()\n  })\n\n  it('throws when two build handlers list the same resolved operator, naming both handlers and the operator', () => {\n    expect(() =>\n      validateOperatorHandlers([\n        replacementHandler({ name: 'handler-a', operators: ['contains'] }),\n        replacementHandler({ name: 'handler-b', operators: ['contains'] }),\n      ]),\n    ).toThrow(/handler-a/)\n\n    expect(() =>\n      validateOperatorHandlers([\n        replacementHandler({ name: 'handler-a', operators: ['contains'] }),\n        replacementHandler({ name: 'handler-b', operators: ['contains'] }),\n      ]),\n    ).toThrow(/handler-b/)\n\n    expect(() =>\n      validateOperatorHandlers([\n        replacementHandler({ name: 'handler-a', operators: ['contains'] }),\n        replacementHandler({ name: 'handler-b', operators: ['contains'] }),\n      ]),\n    ).toThrow(/contains/)\n  })\n\n  it('does not throw when two build handlers target the same operator but declare disjoint fieldTypes', () => {\n    expect(() =>\n      validateOperatorHandlers([\n        replacementHandler({ name: 'text', operators: ['contains'], fieldTypes: ['text'] }),\n        replacementHandler({ name: 'number', operators: ['contains'], fieldTypes: ['number'] }),\n      ]),\n    ).not.toThrow()\n  })\n\n  it('throws when two build handlers target the same operator and at least one declares no fieldTypes', () => {\n    expect(() =>\n      validateOperatorHandlers([\n        replacementHandler({ name: 'unrestricted', operators: ['contains'] }),\n        replacementHandler({ name: 'text', operators: ['contains'], fieldTypes: ['text'] }),\n      ]),\n    ).toThrow()\n  })\n\n  it('throws when a handler object defines both build and transformOperands', () => {\n    const malformed = {\n      name: 'malformed',\n      operators: ['contains'],\n      build: () => null as any,\n      transformOperands: ({ column, value }: any) => ({ column, value }),\n    } as unknown as DrizzleOperatorHandler\n\n    expect(() => validateOperatorHandlers([malformed])).toThrow(/malformed/)\n  })\n})\n"],"names":["describe","expect","it","validateOperatorHandlers","transformHandler","overrides","name","operators","transformOperands","column","value","replacementHandler","build","not","toThrow","fieldTypes","malformed"],"mappings":"AAAA,SAASA,QAAQ,EAAEC,MAAM,EAAEC,EAAE,QAAQ,SAAQ;AAI7C,SAASC,wBAAwB,QAAQ,gCAA+B;AAExE,MAAMC,mBAAmB,CACvBC,YAA6C,CAAC,CAAC,GAE9C,CAAA;QACCC,MAAM;QACNC,WAAW;YAAC;SAAW;QACvBC,mBAAmB,CAAC,EAAEC,MAAM,EAAEC,KAAK,EAAE,GAAM,CAAA;gBAAED;gBAAQC;YAAM,CAAA;QAC3D,GAAGL,SAAS;IACd,CAAA;AAEF,MAAMM,qBAAqB,CACzBN,YAA6C,CAAC,CAAC,GAE9C,CAAA;QACCC,MAAM;QACNC,WAAW;YAAC;SAAW;QACvBK,OAAO,IAAM;QACb,GAAGP,SAAS;IACd,CAAA;AAEFL,SAAS,4BAA4B;IACnCE,GAAG,oDAAoD;QACrDD,OAAO,IAAME,yBAAyB,EAAE,GAAGU,GAAG,CAACC,OAAO;IACxD;IAEAZ,GAAG,+EAA+E;QAChFD,OAAO,IACLE,yBAAyB;gBACvBC,iBAAiB;oBAAEE,MAAM;gBAAI;gBAC7BF,iBAAiB;oBAAEE,MAAM;gBAAI;gBAC7BF,iBAAiB;oBAAEE,MAAM;gBAAI;aAC9B,GACDO,GAAG,CAACC,OAAO;IACf;IAEAZ,GAAG,yGAAyG;QAC1GD,OAAO,IACLE,yBAAyB;gBACvBQ,mBAAmB;oBAAEL,MAAM;oBAAaC,WAAW;wBAAC;qBAAW;gBAAC;gBAChEI,mBAAmB;oBAAEL,MAAM;oBAAaC,WAAW;wBAAC;qBAAW;gBAAC;aACjE,GACDO,OAAO,CAAC;QAEVb,OAAO,IACLE,yBAAyB;gBACvBQ,mBAAmB;oBAAEL,MAAM;oBAAaC,WAAW;wBAAC;qBAAW;gBAAC;gBAChEI,mBAAmB;oBAAEL,MAAM;oBAAaC,WAAW;wBAAC;qBAAW;gBAAC;aACjE,GACDO,OAAO,CAAC;QAEVb,OAAO,IACLE,yBAAyB;gBACvBQ,mBAAmB;oBAAEL,MAAM;oBAAaC,WAAW;wBAAC;qBAAW;gBAAC;gBAChEI,mBAAmB;oBAAEL,MAAM;oBAAaC,WAAW;wBAAC;qBAAW;gBAAC;aACjE,GACDO,OAAO,CAAC;IACZ;IAEAZ,GAAG,mGAAmG;QACpGD,OAAO,IACLE,yBAAyB;gBACvBQ,mBAAmB;oBAAEL,MAAM;oBAAQC,WAAW;wBAAC;qBAAW;oBAAEQ,YAAY;wBAAC;qBAAO;gBAAC;gBACjFJ,mBAAmB;oBAAEL,MAAM;oBAAUC,WAAW;wBAAC;qBAAW;oBAAEQ,YAAY;wBAAC;qBAAS;gBAAC;aACtF,GACDF,GAAG,CAACC,OAAO;IACf;IAEAZ,GAAG,mGAAmG;QACpGD,OAAO,IACLE,yBAAyB;gBACvBQ,mBAAmB;oBAAEL,MAAM;oBAAgBC,WAAW;wBAAC;qBAAW;gBAAC;gBACnEI,mBAAmB;oBAAEL,MAAM;oBAAQC,WAAW;wBAAC;qBAAW;oBAAEQ,YAAY;wBAAC;qBAAO;gBAAC;aAClF,GACDD,OAAO;IACX;IAEAZ,GAAG,yEAAyE;QAC1E,MAAMc,YAAY;YAChBV,MAAM;YACNC,WAAW;gBAAC;aAAW;YACvBK,OAAO,IAAM;YACbJ,mBAAmB,CAAC,EAAEC,MAAM,EAAEC,KAAK,EAAO,GAAM,CAAA;oBAAED;oBAAQC;gBAAM,CAAA;QAClE;QAEAT,OAAO,IAAME,yBAAyB;gBAACa;aAAU,GAAGF,OAAO,CAAC;IAC9D;AACF"}

package/dist/schema/buildRawSchema.spec.js

@@ -0,0 +1,290 @@
+import { sanitizeConfig } from 'payload';
+import { describe, expect, it, vi } from 'vitest';
+import { setColumnID } from '../postgres/schema/setColumnID.js';
+import { checkTruncatedIdentifiers } from '../utilities/checkTruncatedIdentifiers.js';
+import { buildRawSchema } from './buildRawSchema.js';
+const headlineBlock = {
+    slug: 'headline',
+    fields: [
+        {
+            name: 'title',
+            type: 'text'
+        }
+    ]
+};
+const createContainerBlock = (slug)=>({
+        slug,
+        fields: [
+            {
+                name: 'content',
+                type: 'blocks',
+                blocks: [
+                    'headline'
+                ]
+            }
+        ]
+    });
+const createAdapter = (config, warn = ()=>{})=>({
+        blocksAsJSON: false,
+        fieldConstraints: {},
+        idType: 'serial',
+        localesSuffix: '_locales',
+        payload: {
+            blocks: Object.fromEntries(config.blocks.map((block)=>[
+                    block.slug,
+                    block
+                ])),
+            collections: Object.fromEntries(config.collections.map((collection)=>[
+                    collection.slug,
+                    {
+                        config: collection,
+                        customIDType: undefined
+                    }
+                ])),
+            config,
+            logger: {
+                warn
+            }
+        },
+        rawRelations: {},
+        rawTables: {},
+        tableNameMap: new Map(),
+        versionsSuffix: '_versions'
+    });
+describe('buildRawSchema', ()=>{
+    it('should create suffixed block tables for different schemas with the same slug', async ()=>{
+        const config = sanitizeConfig({
+            collections: [
+                {
+                    slug: 'pages',
+                    fields: [
+                        {
+                            name: 'primaryContent',
+                            type: 'blocks',
+                            localized: true,
+                            blocks: [
+                                {
+                                    slug: 'content',
+                                    fields: [
+                                        {
+                                            name: 'title',
+                                            type: 'text'
+                                        }
+                                    ]
+                                }
+                            ]
+                        },
+                        {
+                            name: 'secondaryContent',
+                            type: 'blocks',
+                            localized: true,
+                            blocks: [
+                                {
+                                    slug: 'content',
+                                    fields: [
+                                        {
+                                            name: 'description',
+                                            type: 'textarea'
+                                        }
+                                    ]
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ],
+            localization: {
+                defaultLocale: 'en',
+                locales: [
+                    'en',
+                    'de'
+                ]
+            }
+        });
+        const adapter = createAdapter(config);
+        buildRawSchema({
+            adapter,
+            setColumnID
+        });
+        expect(adapter.rawTables.pages_blocks_content.columns.title).toBeDefined();
+        expect(adapter.rawTables.pages_blocks_content.columns._locale).toBeDefined();
+        expect(adapter.rawTables.pages_blocks_content_2.columns.description).toBeDefined();
+        expect(adapter.rawTables.pages_blocks_content_2.columns._locale).toBeDefined();
+    });
+    it('should not create duplicate suffixed block tables for identical reused blocks under localized ancestors', async ()=>{
+        const layoutBlocks = [
+            createContainerBlock('container'),
+            createContainerBlock('container50')
+        ];
+        const config = sanitizeConfig({
+            blocks: [
+                headlineBlock
+            ],
+            collections: [
+                {
+                    slug: 'pages',
+                    fields: [
+                        {
+                            name: 'layout',
+                            type: 'blocks',
+                            localized: true,
+                            blocks: layoutBlocks
+                        }
+                    ]
+                },
+                {
+                    slug: 'posts',
+                    fields: [
+                        {
+                            name: 'layout',
+                            type: 'blocks',
+                            localized: true,
+                            blocks: layoutBlocks
+                        }
+                    ]
+                }
+            ],
+            localization: {
+                defaultLocale: 'en',
+                locales: [
+                    'en',
+                    'de'
+                ]
+            }
+        });
+        const adapter = createAdapter(config);
+        buildRawSchema({
+            adapter,
+            setColumnID
+        });
+        expect(adapter.rawTables.pages_blocks_headline).toBeDefined();
+        expect(adapter.rawTables.pages_blocks_headline.columns._locale).toBeDefined();
+        expect(adapter.rawTables.pages_blocks_headline_2).toBeUndefined();
+        expect(adapter.rawTables.pages_blocks_headline_2_locales).toBeUndefined();
+        expect(adapter.rawTables.posts_blocks_headline).toBeDefined();
+        expect(adapter.rawTables.posts_blocks_headline.columns._locale).toBeDefined();
+        expect(adapter.rawTables.posts_blocks_headline_2).toBeUndefined();
+        expect(adapter.rawTables.posts_blocks_headline_2_locales).toBeUndefined();
+    });
+    it('should warn when a localized field pushes the _locales companion table past 63 chars', async ()=>{
+        // Base table name (61 chars) is under the limit, but `${base}_locales` (69) overflows it.
+        const longSlug = `localized_collection_${'x'.repeat(40)}`;
+        const config = sanitizeConfig({
+            collections: [
+                {
+                    slug: longSlug,
+                    fields: [
+                        {
+                            name: 'title',
+                            type: 'text',
+                            localized: true
+                        }
+                    ],
+                    timestamps: false,
+                    versions: false
+                }
+            ],
+            localization: {
+                defaultLocale: 'en',
+                locales: [
+                    'en',
+                    'de'
+                ]
+            }
+        });
+        const warn = vi.fn();
+        const adapter = createAdapter(config, warn);
+        buildRawSchema({
+            adapter,
+            setColumnID
+        });
+        expect(adapter.rawTables[`${longSlug}_locales`]).toBeDefined();
+        expect(()=>checkTruncatedIdentifiers({
+                adapter,
+                logWarnings: true
+            })).not.toThrow();
+        expect(warn).toHaveBeenCalledTimes(1);
+        expect(warn.mock.calls[0][0]).toContain(`${longSlug}_locales`);
+    });
+    it('should not warn when the _locales companion table fits within 63 chars', async ()=>{
+        const config = sanitizeConfig({
+            collections: [
+                {
+                    slug: 'short_localized',
+                    fields: [
+                        {
+                            name: 'title',
+                            type: 'text',
+                            localized: true
+                        }
+                    ],
+                    timestamps: false,
+                    versions: false
+                }
+            ],
+            localization: {
+                defaultLocale: 'en',
+                locales: [
+                    'en',
+                    'de'
+                ]
+            }
+        });
+        const warn = vi.fn();
+        const adapter = createAdapter(config, warn);
+        buildRawSchema({
+            adapter,
+            setColumnID
+        });
+        expect(adapter.rawTables.short_localized_locales).toBeDefined();
+        checkTruncatedIdentifiers({
+            adapter,
+            logWarnings: true
+        });
+        expect(warn).not.toHaveBeenCalled();
+    });
+    it('should warn about raw inline sub-table index and foreign key names that exceed 63 chars', async ()=>{
+        // Array sub-tables assign structural index/FK names inline (not via buildIndexName/
+        // buildForeignKeyName), so a long-but-valid array table name still overflows them.
+        const arrayFieldName = 'a'.repeat(58);
+        const config = sanitizeConfig({
+            collections: [
+                {
+                    slug: 'p',
+                    fields: [
+                        {
+                            name: arrayFieldName,
+                            type: 'array',
+                            fields: [
+                                {
+                                    name: 'title',
+                                    type: 'text'
+                                }
+                            ]
+                        }
+                    ],
+                    timestamps: false,
+                    versions: false
+                }
+            ]
+        });
+        const warn = vi.fn();
+        const adapter = createAdapter(config, warn);
+        buildRawSchema({
+            adapter,
+            setColumnID
+        });
+        const arrayTable = `p_${arrayFieldName}`;
+        checkTruncatedIdentifiers({
+            adapter,
+            logWarnings: true
+        });
+        expect(arrayTable.length).toBeLessThanOrEqual(63);
+        expect(warn).toHaveBeenCalledTimes(1);
+        const message = warn.mock.calls[0][0];
+        expect(message).toContain(`${arrayTable}_order_idx`);
+        expect(message).toContain(`${arrayTable}_parent_id_fk`);
+    });
+});
+
+//# sourceMappingURL=buildRawSchema.spec.js.map

package/dist/schema/buildRawSchema.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/schema/buildRawSchema.spec.ts"],"sourcesContent":["import type { Block, Config, SanitizedConfig } from 'payload'\nimport { sanitizeConfig } from 'payload'\nimport { describe, expect, it, vi } from 'vitest'\n\nimport { setColumnID } from '../postgres/schema/setColumnID.js'\nimport type { DrizzleAdapter } from '../types.js'\nimport { checkTruncatedIdentifiers } from '../utilities/checkTruncatedIdentifiers.js'\nimport { buildRawSchema } from './buildRawSchema.js'\n\nconst headlineBlock: Block = {\n  slug: 'headline',\n  fields: [\n    {\n      name: 'title',\n      type: 'text',\n    },\n  ],\n}\n\nconst createContainerBlock = (slug: string): Block => ({\n  slug,\n  fields: [\n    {\n      name: 'content',\n      type: 'blocks',\n      blocks: ['headline'],\n    },\n  ],\n})\n\nconst createAdapter = (\n  config: SanitizedConfig,\n  warn: (...args: any[]) => void = () => {},\n): DrizzleAdapter =>\n  ({\n    blocksAsJSON: false,\n    fieldConstraints: {},\n    idType: 'serial',\n    localesSuffix: '_locales',\n    payload: {\n      blocks: Object.fromEntries(config.blocks.map((block) => [block.slug, block])),\n      collections: Object.fromEntries(\n        config.collections.map((collection) => [\n          collection.slug,\n          {\n            config: collection,\n            customIDType: undefined,\n          },\n        ]),\n      ),\n      config,\n      logger: { warn },\n    },\n    rawRelations: {},\n    rawTables: {},\n    tableNameMap: new Map(),\n    versionsSuffix: '_versions',\n  }) as unknown as DrizzleAdapter\n\ndescribe('buildRawSchema', () => {\n  it('should create suffixed block tables for different schemas with the same slug', async () => {\n    const config = sanitizeConfig({\n      collections: [\n        {\n          slug: 'pages',\n          fields: [\n            {\n              name: 'primaryContent',\n              type: 'blocks',\n              localized: true,\n              blocks: [\n                {\n                  slug: 'content',\n                  fields: [\n                    {\n                      name: 'title',\n                      type: 'text',\n                    },\n                  ],\n                },\n              ],\n            },\n            {\n              name: 'secondaryContent',\n              type: 'blocks',\n              localized: true,\n              blocks: [\n                {\n                  slug: 'content',\n                  fields: [\n                    {\n                      name: 'description',\n                      type: 'textarea',\n                    },\n                  ],\n                },\n              ],\n            },\n          ],\n        },\n      ],\n      localization: {\n        defaultLocale: 'en',\n        locales: ['en', 'de'],\n      },\n    } as Config)\n\n    const adapter = createAdapter(config)\n\n    buildRawSchema({\n      adapter,\n      setColumnID,\n    })\n\n    expect(adapter.rawTables.pages_blocks_content.columns.title).toBeDefined()\n    expect(adapter.rawTables.pages_blocks_content.columns._locale).toBeDefined()\n    expect(adapter.rawTables.pages_blocks_content_2.columns.description).toBeDefined()\n    expect(adapter.rawTables.pages_blocks_content_2.columns._locale).toBeDefined()\n  })\n\n  it('should not create duplicate suffixed block tables for identical reused blocks under localized ancestors', async () => {\n    const layoutBlocks = [createContainerBlock('container'), createContainerBlock('container50')]\n\n    const config = sanitizeConfig({\n      blocks: [headlineBlock],\n      collections: [\n        {\n          slug: 'pages',\n          fields: [\n            {\n              name: 'layout',\n              type: 'blocks',\n              localized: true,\n              blocks: layoutBlocks,\n            },\n          ],\n        },\n        {\n          slug: 'posts',\n          fields: [\n            {\n              name: 'layout',\n              type: 'blocks',\n              localized: true,\n              blocks: layoutBlocks,\n            },\n          ],\n        },\n      ],\n      localization: {\n        defaultLocale: 'en',\n        locales: ['en', 'de'],\n      },\n    } as Config)\n\n    const adapter = createAdapter(config)\n\n    buildRawSchema({\n      adapter,\n      setColumnID,\n    })\n\n    expect(adapter.rawTables.pages_blocks_headline).toBeDefined()\n    expect(adapter.rawTables.pages_blocks_headline.columns._locale).toBeDefined()\n    expect(adapter.rawTables.pages_blocks_headline_2).toBeUndefined()\n    expect(adapter.rawTables.pages_blocks_headline_2_locales).toBeUndefined()\n    expect(adapter.rawTables.posts_blocks_headline).toBeDefined()\n    expect(adapter.rawTables.posts_blocks_headline.columns._locale).toBeDefined()\n    expect(adapter.rawTables.posts_blocks_headline_2).toBeUndefined()\n    expect(adapter.rawTables.posts_blocks_headline_2_locales).toBeUndefined()\n  })\n\n  it('should warn when a localized field pushes the _locales companion table past 63 chars', async () => {\n    // Base table name (61 chars) is under the limit, but `${base}_locales` (69) overflows it.\n    const longSlug = `localized_collection_${'x'.repeat(40)}`\n\n    const config = sanitizeConfig({\n      collections: [\n        {\n          slug: longSlug,\n          fields: [\n            {\n              name: 'title',\n              type: 'text',\n              localized: true,\n            },\n          ],\n          timestamps: false,\n          versions: false,\n        },\n      ],\n      localization: {\n        defaultLocale: 'en',\n        locales: ['en', 'de'],\n      },\n    } as Config)\n\n    const warn = vi.fn()\n    const adapter = createAdapter(config, warn)\n\n    buildRawSchema({ adapter, setColumnID })\n\n    expect(adapter.rawTables[`${longSlug}_locales`]).toBeDefined()\n\n    expect(() => checkTruncatedIdentifiers({ adapter, logWarnings: true })).not.toThrow()\n    expect(warn).toHaveBeenCalledTimes(1)\n    expect(warn.mock.calls[0][0]).toContain(`${longSlug}_locales`)\n  })\n\n  it('should not warn when the _locales companion table fits within 63 chars', async () => {\n    const config = sanitizeConfig({\n      collections: [\n        {\n          slug: 'short_localized',\n          fields: [\n            {\n              name: 'title',\n              type: 'text',\n              localized: true,\n            },\n          ],\n          timestamps: false,\n          versions: false,\n        },\n      ],\n      localization: {\n        defaultLocale: 'en',\n        locales: ['en', 'de'],\n      },\n    } as Config)\n\n    const warn = vi.fn()\n    const adapter = createAdapter(config, warn)\n\n    buildRawSchema({ adapter, setColumnID })\n\n    expect(adapter.rawTables.short_localized_locales).toBeDefined()\n\n    checkTruncatedIdentifiers({ adapter, logWarnings: true })\n\n    expect(warn).not.toHaveBeenCalled()\n  })\n\n  it('should warn about raw inline sub-table index and foreign key names that exceed 63 chars', async () => {\n    // Array sub-tables assign structural index/FK names inline (not via buildIndexName/\n    // buildForeignKeyName), so a long-but-valid array table name still overflows them.\n    const arrayFieldName = 'a'.repeat(58)\n\n    const config = sanitizeConfig({\n      collections: [\n        {\n          slug: 'p',\n          fields: [\n            {\n              name: arrayFieldName,\n              type: 'array',\n              fields: [{ name: 'title', type: 'text' }],\n            },\n          ],\n          timestamps: false,\n          versions: false,\n        },\n      ],\n    } as Config)\n\n    const warn = vi.fn()\n    const adapter = createAdapter(config, warn)\n\n    buildRawSchema({ adapter, setColumnID })\n\n    const arrayTable = `p_${arrayFieldName}`\n\n    checkTruncatedIdentifiers({ adapter, logWarnings: true })\n\n    expect(arrayTable.length).toBeLessThanOrEqual(63)\n    expect(warn).toHaveBeenCalledTimes(1)\n\n    const message: string = warn.mock.calls[0][0]\n\n    expect(message).toContain(`${arrayTable}_order_idx`)\n    expect(message).toContain(`${arrayTable}_parent_id_fk`)\n  })\n})\n"],"names":["sanitizeConfig","describe","expect","it","vi","setColumnID","checkTruncatedIdentifiers","buildRawSchema","headlineBlock","slug","fields","name","type","createContainerBlock","blocks","createAdapter","config","warn","blocksAsJSON","fieldConstraints","idType","localesSuffix","payload","Object","fromEntries","map","block","collections","collection","customIDType","undefined","logger","rawRelations","rawTables","tableNameMap","Map","versionsSuffix","localized","localization","defaultLocale","locales","adapter","pages_blocks_content","columns","title","toBeDefined","_locale","pages_blocks_content_2","description","layoutBlocks","pages_blocks_headline","pages_blocks_headline_2","toBeUndefined","pages_blocks_headline_2_locales","posts_blocks_headline","posts_blocks_headline_2","posts_blocks_headline_2_locales","longSlug","repeat","timestamps","versions","fn","logWarnings","not","toThrow","toHaveBeenCalledTimes","mock","calls","toContain","short_localized_locales","toHaveBeenCalled","arrayFieldName","arrayTable","length","toBeLessThanOrEqual","message"],"mappings":"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"}

package/dist/schema/traverseFields.js

@@ -269,12 +269,13 @@ export const traverseFields = ({ adapter, blocksTableNameMap, columnPrefix, colu
                             throwValidationError,
                             versionsCustomName: versions
                         });
+                        const isLocalizedBlockTable = Boolean(isFieldLocalized && adapter.payload.config.localization) || withinLocalizedArrayOrBlock || forceLocalized;
                         if (typeof blocksTableNameMap[blockTableName] === 'undefined') {
                             blocksTableNameMap[blockTableName] = 1;
                         } else if (!adapter.rawTables[blockTableName] || !validateExistingBlockIsIdentical({
                             block,
-                            localized: field.localized,
-                            rootTableName,
+                            localized: isLocalizedBlockTable,
+                            parentIsLocalized,
                             table: adapter.rawTables[blockTableName],
                             tableLocales: adapter.rawTables[`${blockTableName}${adapter.localesSuffix}`]
                         })) {
@@ -335,8 +336,7 @@ export const traverseFields = ({ adapter, blocksTableNameMap, columnPrefix, colu
                                     onDelete: 'cascade'
                                 }
                             };
-                            const isLocalized = Boolean(isFieldLocalized && adapter.payload.config.localization) || withinLocalizedArrayOrBlock || forceLocalized;
-                            if (isLocalized) {
+                            if (isLocalizedBlockTable) {
                                 baseColumns._locale = {
                                     name: '_locale',
                                     type: 'enum',
@@ -367,7 +367,7 @@ export const traverseFields = ({ adapter, blocksTableNameMap, columnPrefix, colu
                                 setColumnID,
                                 tableName: blockTableName,
                                 versions,
-                                withinLocalizedArrayOrBlock: isLocalized
+                                withinLocalizedArrayOrBlock: isLocalizedBlockTable
                             });
                             if (subHasLocalizedManyNumberField) {
                                 hasLocalizedManyNumberField = subHasLocalizedManyNumberField;