@payloadcms/drizzle 3.7.0 → 3.7.1-canary.2ce70a3

package/dist/{postgres/schema → schema}/build.d.ts

@@ -1,14 +1,18 @@
-import type { PgColumnBuilder } from 'drizzle-orm/pg-core';
 import type { FlattenedField } from 'payload';
-import type { BaseExtraConfig, BasePostgresAdapter, RelationMap } from '../types.js';
+import type { DrizzleAdapter, IDType, RawColumn, RawForeignKey, RawIndex, RelationMap, SetColumnID } from '../types.js';
 type Args = {
-    adapter: BasePostgresAdapter;
-    baseColumns?: Record<string, PgColumnBuilder>;
+    adapter: DrizzleAdapter;
+    baseColumns?: Record<string, RawColumn>;
     /**
      * After table is created, run these functions to add extra config to the table
      * ie. indexes, multiple columns, etc
      */
-    baseExtraConfig?: BaseExtraConfig;
+    baseForeignKeys?: Record<string, RawForeignKey>;
+    /**
+     * After table is created, run these functions to add extra config to the table
+     * ie. indexes, multiple columns, etc
+     */
+    baseIndexes?: Record<string, RawIndex>;
     buildNumbers?: boolean;
     buildRelationships?: boolean;
     disableNotNull: boolean;
@@ -17,9 +21,10 @@ type Args = {
     fields: FlattenedField[];
     rootRelationships?: Set<string>;
     rootRelationsToBuild?: RelationMap;
-    rootTableIDColType?: string;
+    rootTableIDColType?: IDType;
     rootTableName?: string;
     rootUniqueRelationships?: Set<string>;
+    setColumnID: SetColumnID;
     tableName: string;
     timestamps?: boolean;
     versions: boolean;
@@ -37,6 +42,6 @@ type Result = {
     hasManyTextField: 'index' | boolean;
     relationsToBuild: RelationMap;
 };
-export declare const buildTable: ({ adapter, baseColumns, baseExtraConfig, disableNotNull, disableRelsTableUnique, disableUnique, fields, rootRelationships, rootRelationsToBuild, rootTableIDColType, rootTableName: incomingRootTableName, rootUniqueRelationships, tableName, timestamps, versions, withinLocalizedArrayOrBlock, }: Args) => Result;
+export declare const buildTable: ({ adapter, baseColumns, baseForeignKeys, baseIndexes, disableNotNull, disableRelsTableUnique, disableUnique, fields, rootRelationships, rootRelationsToBuild, rootTableIDColType, rootTableName: incomingRootTableName, rootUniqueRelationships, setColumnID, tableName, timestamps, versions, withinLocalizedArrayOrBlock, }: Args) => Result;
 export {};
 //# sourceMappingURL=build.d.ts.map

package/dist/schema/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/schema/build.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAI7C,OAAO,KAAK,EACV,cAAc,EACd,MAAM,EACN,SAAS,EACT,aAAa,EACb,QAAQ,EAGR,WAAW,EACX,WAAW,EACZ,MAAM,aAAa,CAAA;AAMpB,KAAK,IAAI,GAAG;IACV,OAAO,EAAE,cAAc,CAAA;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;IACvC;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IAC/C;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;IACtC,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,kBAAkB,CAAC,EAAE,OAAO,CAAA;IAC5B,cAAc,EAAE,OAAO,CAAA;IACvB,sBAAsB,CAAC,EAAE,OAAO,CAAA;IAChC,aAAa,EAAE,OAAO,CAAA;IACtB,MAAM,EAAE,cAAc,EAAE,CAAA;IACxB,iBAAiB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAC/B,oBAAoB,CAAC,EAAE,WAAW,CAAA;IAClC,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,uBAAuB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IACrC,WAAW,EAAE,WAAW,CAAA;IACxB,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,QAAQ,EAAE,OAAO,CAAA;IACjB;;;OAGG;IACH,2BAA2B,CAAC,EAAE,OAAO,CAAA;CACtC,CAAA;AAED,KAAK,MAAM,GAAG;IACZ,2BAA2B,EAAE,OAAO,CAAA;IACpC,yBAAyB,EAAE,OAAO,CAAA;IAClC,6BAA6B,EAAE,OAAO,CAAA;IACtC,kBAAkB,EAAE,OAAO,GAAG,OAAO,CAAA;IACrC,gBAAgB,EAAE,OAAO,GAAG,OAAO,CAAA;IACnC,gBAAgB,EAAE,WAAW,CAAA;CAC9B,CAAA;AAED,eAAO,MAAM,UAAU,kUAmBpB,IAAI,KAAG,MA6mBT,CAAA"}

package/dist/schema/build.js

@@ -0,0 +1,603 @@
+import toSnakeCase from 'to-snake-case';
+import { createTableName } from '../createTableName.js';
+import { buildIndexName } from '../utilities/buildIndexName.js';
+import { traverseFields } from './traverseFields.js';
+export const buildTable = ({ adapter, baseColumns = {}, baseForeignKeys = {}, baseIndexes = {}, disableNotNull, disableRelsTableUnique = false, disableUnique = false, fields, rootRelationships, rootRelationsToBuild, rootTableIDColType, rootTableName: incomingRootTableName, rootUniqueRelationships, setColumnID, tableName, timestamps, versions, withinLocalizedArrayOrBlock })=>{
+    const isRoot = !incomingRootTableName;
+    const rootTableName = incomingRootTableName || tableName;
+    const columns = baseColumns;
+    const indexes = baseIndexes;
+    const localesColumns = {};
+    const localesIndexes = {};
+    let localesTable;
+    let textsTable;
+    let numbersTable;
+    // Relationships to the base collection
+    const relationships = rootRelationships || new Set();
+    // Unique relationships to the base collection
+    const uniqueRelationships = rootUniqueRelationships || new Set();
+    let relationshipsTable;
+    // Drizzle relations
+    const relationsToBuild = new Map();
+    const idColType = setColumnID({
+        adapter,
+        columns,
+        fields
+    });
+    const { hasLocalizedField, hasLocalizedManyNumberField, hasLocalizedManyTextField, hasLocalizedRelationshipField, hasManyNumberField, hasManyTextField } = traverseFields({
+        adapter,
+        columns,
+        disableNotNull,
+        disableRelsTableUnique,
+        disableUnique,
+        fields,
+        indexes,
+        localesColumns,
+        localesIndexes,
+        newTableName: tableName,
+        parentTableName: tableName,
+        relationships,
+        relationsToBuild,
+        rootRelationsToBuild: rootRelationsToBuild || relationsToBuild,
+        rootTableIDColType: rootTableIDColType || idColType,
+        rootTableName,
+        setColumnID,
+        uniqueRelationships,
+        versions,
+        withinLocalizedArrayOrBlock
+    });
+    // split the relationsToBuild by localized and non-localized
+    const localizedRelations = new Map();
+    const nonLocalizedRelations = new Map();
+    relationsToBuild.forEach(({ type, localized, relationName, target }, key)=>{
+        const map = localized ? localizedRelations : nonLocalizedRelations;
+        map.set(key, {
+            type,
+            relationName,
+            target
+        });
+    });
+    if (timestamps) {
+        columns.createdAt = {
+            name: 'created_at',
+            type: 'timestamp',
+            defaultNow: true,
+            mode: 'string',
+            notNull: true,
+            precision: 3,
+            withTimezone: true
+        };
+        columns.updatedAt = {
+            name: 'updated_at',
+            type: 'timestamp',
+            defaultNow: true,
+            mode: 'string',
+            notNull: true,
+            precision: 3,
+            withTimezone: true
+        };
+    }
+    const table = {
+        name: tableName,
+        columns,
+        foreignKeys: baseForeignKeys,
+        indexes
+    };
+    adapter.rawTables[tableName] = table;
+    if (hasLocalizedField || localizedRelations.size) {
+        const localeTableName = `${tableName}${adapter.localesSuffix}`;
+        localesColumns.id = {
+            name: 'id',
+            type: 'serial',
+            primaryKey: true
+        };
+        localesColumns._locale = {
+            name: '_locale',
+            type: 'enum',
+            locale: true,
+            notNull: true
+        };
+        localesColumns._parentID = {
+            name: '_parent_id',
+            type: idColType,
+            notNull: true
+        };
+        localesIndexes._localeParent = {
+            name: `${localeTableName}_locale_parent_id_unique`,
+            on: [
+                '_locale',
+                '_parentID'
+            ],
+            unique: true
+        };
+        localesTable = {
+            name: localeTableName,
+            columns: localesColumns,
+            foreignKeys: {
+                _parentIdFk: {
+                    name: `${localeTableName}_parent_id_fk`,
+                    columns: [
+                        '_parentID'
+                    ],
+                    foreignColumns: [
+                        {
+                            name: 'id',
+                            table: tableName
+                        }
+                    ],
+                    onDelete: 'cascade'
+                }
+            },
+            indexes: localesIndexes
+        };
+        adapter.rawTables[localeTableName] = localesTable;
+        const localeRelations = {
+            _parentID: {
+                type: 'one',
+                fields: [
+                    {
+                        name: '_parentID',
+                        table: localeTableName
+                    }
+                ],
+                references: [
+                    'id'
+                ],
+                relationName: '_locales',
+                to: tableName
+            }
+        };
+        localizedRelations.forEach(({ type, target }, key)=>{
+            if (type === 'one') {
+                localeRelations[key] = {
+                    type: 'one',
+                    fields: [
+                        {
+                            name: key,
+                            table: localeTableName
+                        }
+                    ],
+                    references: [
+                        'id'
+                    ],
+                    relationName: key,
+                    to: target
+                };
+            }
+            if (type === 'many') {
+                localeRelations[key] = {
+                    type: 'many',
+                    relationName: key,
+                    to: target
+                };
+            }
+        });
+        adapter.rawRelations[localeTableName] = localeRelations;
+    }
+    if (isRoot) {
+        if (hasManyTextField) {
+            const textsTableName = `${rootTableName}_texts`;
+            const columns = {
+                id: {
+                    name: 'id',
+                    type: 'serial',
+                    primaryKey: true
+                },
+                order: {
+                    name: 'order',
+                    type: 'integer',
+                    notNull: true
+                },
+                parent: {
+                    name: 'parent_id',
+                    type: idColType,
+                    notNull: true
+                },
+                path: {
+                    name: 'path',
+                    type: 'varchar',
+                    notNull: true
+                },
+                text: {
+                    name: 'text',
+                    type: 'varchar'
+                }
+            };
+            if (hasLocalizedManyTextField) {
+                columns.locale = {
+                    name: 'locale',
+                    type: 'enum',
+                    locale: true
+                };
+            }
+            const textsTableIndexes = {
+                orderParentIdx: {
+                    name: `${textsTableName}_order_parent_idx`,
+                    on: [
+                        'order',
+                        'parent'
+                    ]
+                }
+            };
+            if (hasManyTextField === 'index') {
+                textsTableIndexes.text_idx = {
+                    name: `${textsTableName}_text_idx`,
+                    on: 'text'
+                };
+            }
+            if (hasLocalizedManyTextField) {
+                textsTableIndexes.localeParent = {
+                    name: `${textsTableName}_locale_parent`,
+                    on: [
+                        'locale',
+                        'parent'
+                    ]
+                };
+            }
+            textsTable = {
+                name: textsTableName,
+                columns,
+                foreignKeys: {
+                    parentFk: {
+                        name: `${textsTableName}_parent_fk`,
+                        columns: [
+                            'parent'
+                        ],
+                        foreignColumns: [
+                            {
+                                name: 'id',
+                                table: tableName
+                            }
+                        ],
+                        onDelete: 'cascade'
+                    }
+                },
+                indexes: textsTableIndexes
+            };
+            adapter.rawTables[textsTableName] = textsTable;
+            adapter.rawRelations[textsTableName] = {
+                parent: {
+                    type: 'one',
+                    fields: [
+                        {
+                            name: 'parent',
+                            table: textsTableName
+                        }
+                    ],
+                    references: [
+                        'id'
+                    ],
+                    relationName: '_texts',
+                    to: tableName
+                }
+            };
+        }
+        if (hasManyNumberField) {
+            const numbersTableName = `${rootTableName}_numbers`;
+            const columns = {
+                id: {
+                    name: 'id',
+                    type: 'serial',
+                    primaryKey: true
+                },
+                number: {
+                    name: 'number',
+                    type: 'numeric'
+                },
+                order: {
+                    name: 'order',
+                    type: 'integer',
+                    notNull: true
+                },
+                parent: {
+                    name: 'parent_id',
+                    type: idColType,
+                    notNull: true
+                },
+                path: {
+                    name: 'path',
+                    type: 'varchar',
+                    notNull: true
+                }
+            };
+            if (hasLocalizedManyNumberField) {
+                columns.locale = {
+                    name: 'locale',
+                    type: 'enum',
+                    locale: true
+                };
+            }
+            const numbersTableIndexes = {
+                orderParentIdx: {
+                    name: `${numbersTableName}_order_parent_idx`,
+                    on: [
+                        'order',
+                        'parent'
+                    ]
+                }
+            };
+            if (hasManyNumberField === 'index') {
+                numbersTableIndexes.numberIdx = {
+                    name: `${numbersTableName}_number_idx`,
+                    on: 'number'
+                };
+            }
+            if (hasLocalizedManyNumberField) {
+                numbersTableIndexes.localeParent = {
+                    name: `${numbersTableName}_locale_parent`,
+                    on: [
+                        'locale',
+                        'parent'
+                    ]
+                };
+            }
+            numbersTable = {
+                name: numbersTableName,
+                columns,
+                foreignKeys: {
+                    parentFk: {
+                        name: `${numbersTableName}_parent_fk`,
+                        columns: [
+                            'parent'
+                        ],
+                        foreignColumns: [
+                            {
+                                name: 'id',
+                                table: tableName
+                            }
+                        ],
+                        onDelete: 'cascade'
+                    }
+                },
+                indexes: numbersTableIndexes
+            };
+            adapter.rawTables[numbersTableName] = numbersTable;
+            adapter.rawRelations[numbersTableName] = {
+                parent: {
+                    type: 'one',
+                    fields: [
+                        {
+                            name: 'parent',
+                            table: numbersTableName
+                        }
+                    ],
+                    references: [
+                        'id'
+                    ],
+                    relationName: '_numbers',
+                    to: tableName
+                }
+            };
+        }
+        if (relationships.size) {
+            const relationshipColumns = {
+                id: {
+                    name: 'id',
+                    type: 'serial',
+                    primaryKey: true
+                },
+                order: {
+                    name: 'order',
+                    type: 'integer'
+                },
+                parent: {
+                    name: 'parent_id',
+                    type: idColType,
+                    notNull: true
+                },
+                path: {
+                    name: 'path',
+                    type: 'varchar',
+                    notNull: true
+                }
+            };
+            if (hasLocalizedRelationshipField) {
+                relationshipColumns.locale = {
+                    name: 'locale',
+                    type: 'enum',
+                    locale: true
+                };
+            }
+            const relationshipsTableName = `${tableName}${adapter.relationshipsSuffix}`;
+            const relationshipIndexes = {
+                order: {
+                    name: `${relationshipsTableName}_order_idx`,
+                    on: 'order'
+                },
+                parentIdx: {
+                    name: `${relationshipsTableName}_parent_idx`,
+                    on: 'parent'
+                },
+                pathIdx: {
+                    name: `${relationshipsTableName}_path_idx`,
+                    on: 'path'
+                }
+            };
+            if (hasLocalizedRelationshipField) {
+                relationshipIndexes.localeIdx = {
+                    name: `${relationshipsTableName}_locale_idx`,
+                    on: 'locale'
+                };
+            }
+            const relationshipForeignKeys = {
+                parentFk: {
+                    name: `${relationshipsTableName}_parent_fk`,
+                    columns: [
+                        'parent'
+                    ],
+                    foreignColumns: [
+                        {
+                            name: 'id',
+                            table: tableName
+                        }
+                    ],
+                    onDelete: 'cascade'
+                }
+            };
+            relationships.forEach((relationTo)=>{
+                const relationshipConfig = adapter.payload.collections[relationTo].config;
+                const formattedRelationTo = createTableName({
+                    adapter,
+                    config: relationshipConfig,
+                    throwValidationError: true
+                });
+                let colType = adapter.idType === 'uuid' ? 'uuid' : 'integer';
+                const relatedCollectionCustomIDType = adapter.payload.collections[relationshipConfig.slug]?.customIDType;
+                if (relatedCollectionCustomIDType === 'number') {
+                    colType = 'numeric';
+                }
+                if (relatedCollectionCustomIDType === 'text') {
+                    colType = 'varchar';
+                }
+                const colName = `${relationTo}ID`;
+                relationshipColumns[colName] = {
+                    name: `${formattedRelationTo}_id`,
+                    type: colType
+                };
+                relationshipForeignKeys[`${relationTo}IdFk`] = {
+                    name: `${relationshipsTableName}_${toSnakeCase(relationTo)}_fk`,
+                    columns: [
+                        colName
+                    ],
+                    foreignColumns: [
+                        {
+                            name: 'id',
+                            table: formattedRelationTo
+                        }
+                    ],
+                    onDelete: 'cascade'
+                };
+                const indexColumns = [
+                    colName
+                ];
+                const unique = !disableUnique && uniqueRelationships.has(relationTo);
+                if (unique) {
+                    indexColumns.push('path');
+                }
+                if (hasLocalizedRelationshipField) {
+                    indexColumns.push('locale');
+                }
+                const indexName = buildIndexName({
+                    name: `${relationshipsTableName}_${formattedRelationTo}_id`,
+                    adapter
+                });
+                relationshipIndexes[indexName] = {
+                    name: indexName,
+                    on: indexColumns,
+                    unique
+                };
+            });
+            relationshipsTable = {
+                name: relationshipsTableName,
+                columns: relationshipColumns,
+                foreignKeys: relationshipForeignKeys,
+                indexes: relationshipIndexes
+            };
+            adapter.rawTables[relationshipsTableName] = relationshipsTable;
+            const relationshipsTableRelations = {
+                parent: {
+                    type: 'one',
+                    fields: [
+                        {
+                            name: 'parent',
+                            table: relationshipsTableName
+                        }
+                    ],
+                    references: [
+                        'id'
+                    ],
+                    relationName: '_rels',
+                    to: tableName
+                }
+            };
+            relationships.forEach((relationTo)=>{
+                const relatedTableName = createTableName({
+                    adapter,
+                    config: adapter.payload.collections[relationTo].config,
+                    throwValidationError: true
+                });
+                const idColumnName = `${relationTo}ID`;
+                relationshipsTableRelations[idColumnName] = {
+                    type: 'one',
+                    fields: [
+                        {
+                            name: idColumnName,
+                            table: relationshipsTableName
+                        }
+                    ],
+                    references: [
+                        'id'
+                    ],
+                    relationName: relationTo,
+                    to: relatedTableName
+                };
+            });
+            adapter.rawRelations[relationshipsTableName] = relationshipsTableRelations;
+        }
+    }
+    const tableRelations = {};
+    nonLocalizedRelations.forEach(({ type, relationName, target }, key)=>{
+        if (type === 'one') {
+            tableRelations[key] = {
+                type: 'one',
+                fields: [
+                    {
+                        name: key,
+                        table: tableName
+                    }
+                ],
+                references: [
+                    'id'
+                ],
+                relationName: key,
+                to: target
+            };
+        }
+        if (type === 'many') {
+            tableRelations[key] = {
+                type: 'many',
+                relationName: relationName || key,
+                to: target
+            };
+        }
+    });
+    if (hasLocalizedField) {
+        tableRelations._locales = {
+            type: 'many',
+            relationName: '_locales',
+            to: localesTable.name
+        };
+    }
+    if (isRoot && textsTable) {
+        tableRelations._texts = {
+            type: 'many',
+            relationName: '_texts',
+            to: textsTable.name
+        };
+    }
+    if (isRoot && numbersTable) {
+        tableRelations._numbers = {
+            type: 'many',
+            relationName: '_numbers',
+            to: numbersTable.name
+        };
+    }
+    if (relationships.size && relationshipsTable) {
+        tableRelations._rels = {
+            type: 'many',
+            relationName: '_rels',
+            to: relationshipsTable.name
+        };
+    }
+    adapter.rawRelations[tableName] = tableRelations;
+    return {
+        hasLocalizedManyNumberField,
+        hasLocalizedManyTextField,
+        hasLocalizedRelationshipField,
+        hasManyNumberField,
+        hasManyTextField,
+        relationsToBuild
+    };
+};
+
+//# sourceMappingURL=build.js.map