@payloadcms/db-sqlite 3.0.0-beta.69

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import type { Operators } from '@payloadcms/drizzle'\nimport type { DatabaseAdapterObj, Payload } from 'payload'\n\nimport {\n  beginTransaction,\n  commitTransaction,\n  count,\n  create,\n  createGlobal,\n  createGlobalVersion,\n  createVersion,\n  deleteMany,\n  deleteOne,\n  deleteVersions,\n  destroy,\n  find,\n  findGlobal,\n  findGlobalVersions,\n  findMigrationDir,\n  findOne,\n  findVersions,\n  migrate,\n  migrateDown,\n  migrateFresh,\n  migrateRefresh,\n  migrateReset,\n  migrateStatus,\n  operatorMap,\n  queryDrafts,\n  rollbackTransaction,\n  updateGlobal,\n  updateGlobalVersion,\n  updateOne,\n  updateVersion,\n} from '@payloadcms/drizzle'\nimport { like } from 'drizzle-orm'\nimport { createDatabaseAdapter } from 'payload'\n\nimport type { Args, SQLiteAdapter } from './types.js'\n\nimport { connect } from './connect.js'\nimport { countDistinct } from './countDistinct.js'\nimport { convertPathToJSONTraversal } from './createJSONQuery/convertPathToJSONTraversal.js'\nimport { createJSONQuery } from './createJSONQuery/index.js'\nimport { createMigration } from './createMigration.js'\nimport { defaultDrizzleSnapshot } from './defaultSnapshot.js'\nimport { deleteWhere } from './deleteWhere.js'\nimport { dropDatabase } from './dropDatabase.js'\nimport { execute } from './execute.js'\nimport { getMigrationTemplate } from './getMigrationTemplate.js'\nimport { init } from './init.js'\nimport { insert } from './insert.js'\nimport { requireDrizzleKit } from './requireDrizzleKit.js'\n\nexport type { MigrateDownArgs, MigrateUpArgs } from './types.js'\n\nexport { sql } from 'drizzle-orm'\n\nexport function sqliteAdapter(args: Args): DatabaseAdapterObj<SQLiteAdapter> {\n  const postgresIDType = args.idType || 'serial'\n  const payloadIDType = postgresIDType === 'serial' ? 'number' : 'text'\n\n  function adapter({ payload }: { payload: Payload }) {\n    const migrationDir = findMigrationDir(args.migrationDir)\n    let resolveInitializing\n    let rejectInitializing\n\n    const initializing = new Promise<void>((res, rej) => {\n      resolveInitializing = res\n      rejectInitializing = rej\n    })\n\n    // sqlite's like operator is case-insensitive, so we overwrite the DrizzleAdapter operators to not use ilike\n    const operators = {\n      ...operatorMap,\n      contains: like,\n      like,\n    } as unknown as Operators\n\n    return createDatabaseAdapter<SQLiteAdapter>({\n      name: 'sqlite',\n      client: undefined,\n      clientConfig: args.client,\n      defaultDrizzleSnapshot,\n      drizzle: undefined,\n      features: {\n        json: true,\n      },\n      fieldConstraints: {},\n      getMigrationTemplate,\n      idType: postgresIDType,\n      initializing,\n      localesSuffix: args.localesSuffix || '_locales',\n      logger: args.logger,\n      operators,\n      push: args.push,\n      relations: {},\n      relationshipsSuffix: args.relationshipsSuffix || '_rels',\n      schema: {},\n      schemaName: args.schemaName,\n      sessions: {},\n      tableNameMap: new Map<string, string>(),\n      tables: {},\n      transactionOptions: args.transactionOptions || undefined,\n      versionsSuffix: args.versionsSuffix || '_v',\n\n      // DatabaseAdapter\n      beginTransaction: args.transactionOptions === false ? undefined : beginTransaction,\n      commitTransaction,\n      connect,\n      convertPathToJSONTraversal,\n      count,\n      countDistinct,\n      create,\n      createGlobal,\n      createGlobalVersion,\n      createJSONQuery,\n      createMigration,\n      createVersion,\n      defaultIDType: payloadIDType,\n      deleteMany,\n      deleteOne,\n      deleteVersions,\n      deleteWhere,\n      destroy,\n      dropDatabase,\n      execute,\n      find,\n      findGlobal,\n      findGlobalVersions,\n      findOne,\n      findVersions,\n      init,\n      insert,\n      migrate,\n      migrateDown,\n      migrateFresh,\n      migrateRefresh,\n      migrateReset,\n      migrateStatus,\n      migrationDir,\n      payload,\n      queryDrafts,\n      rejectInitializing,\n      requireDrizzleKit,\n      resolveInitializing,\n      rollbackTransaction,\n      updateGlobal,\n      updateGlobalVersion,\n      updateOne,\n      updateVersion,\n    })\n  }\n\n  return {\n    defaultIDType: payloadIDType,\n    init: adapter,\n  }\n}\n"],"names":["beginTransaction","commitTransaction","count","create","createGlobal","createGlobalVersion","createVersion","deleteMany","deleteOne","deleteVersions","destroy","find","findGlobal","findGlobalVersions","findMigrationDir","findOne","findVersions","migrate","migrateDown","migrateFresh","migrateRefresh","migrateReset","migrateStatus","operatorMap","queryDrafts","rollbackTransaction","updateGlobal","updateGlobalVersion","updateOne","updateVersion","like","createDatabaseAdapter","connect","countDistinct","convertPathToJSONTraversal","createJSONQuery","createMigration","defaultDrizzleSnapshot","deleteWhere","dropDatabase","execute","getMigrationTemplate","init","insert","requireDrizzleKit","sql","sqliteAdapter","args","postgresIDType","idType","payloadIDType","adapter","payload","migrationDir","resolveInitializing","rejectInitializing","initializing","Promise","res","rej","operators","contains","name","client","undefined","clientConfig","drizzle","features","json","fieldConstraints","localesSuffix","logger","push","relations","relationshipsSuffix","schema","schemaName","sessions","tableNameMap","Map","tables","transactionOptions","versionsSuffix","defaultIDType"],"mappings":"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"}

package/dist/init.d.ts

@@ -0,0 +1,3 @@
+import type { Init } from 'payload';
+export declare const init: Init;
+//# sourceMappingURL=init.d.ts.map

package/dist/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../src/init.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAA6B,MAAM,SAAS,CAAA;AAU9D,eAAO,MAAM,IAAI,EAAE,IA+FlB,CAAA"}

package/dist/init.js

@@ -0,0 +1,88 @@
+/* eslint-disable no-param-reassign */ import { createTableName } from '@payloadcms/drizzle';
+import { buildVersionCollectionFields, buildVersionGlobalFields } from 'payload';
+import toSnakeCase from 'to-snake-case';
+import { buildTable } from './schema/build.js';
+export const init = function init() {
+    let locales;
+    if (this.payload.config.localization) {
+        locales = this.payload.config.localization.locales.map(({ code })=>code);
+    }
+    this.payload.config.collections.forEach((collection)=>{
+        createTableName({
+            adapter: this,
+            config: collection
+        });
+        if (collection.versions) {
+            createTableName({
+                adapter: this,
+                config: collection,
+                versions: true,
+                versionsCustomName: true
+            });
+        }
+    });
+    this.payload.config.collections.forEach((collection)=>{
+        const tableName = this.tableNameMap.get(toSnakeCase(collection.slug));
+        buildTable({
+            adapter: this,
+            disableNotNull: !!collection?.versions?.drafts,
+            disableUnique: false,
+            fields: collection.fields,
+            locales,
+            tableName,
+            timestamps: collection.timestamps,
+            versions: false
+        });
+        if (collection.versions) {
+            const versionsTableName = this.tableNameMap.get(`_${toSnakeCase(collection.slug)}${this.versionsSuffix}`);
+            const versionFields = buildVersionCollectionFields(collection);
+            buildTable({
+                adapter: this,
+                disableNotNull: !!collection.versions?.drafts,
+                disableUnique: true,
+                fields: versionFields,
+                locales,
+                tableName: versionsTableName,
+                timestamps: true,
+                versions: true
+            });
+        }
+    });
+    this.payload.config.globals.forEach((global)=>{
+        const tableName = createTableName({
+            adapter: this,
+            config: global
+        });
+        buildTable({
+            adapter: this,
+            disableNotNull: !!global?.versions?.drafts,
+            disableUnique: false,
+            fields: global.fields,
+            locales,
+            tableName,
+            timestamps: false,
+            versions: false
+        });
+        if (global.versions) {
+            const versionsTableName = createTableName({
+                adapter: this,
+                config: global,
+                versions: true,
+                versionsCustomName: true
+            });
+            const versionFields = buildVersionGlobalFields(global);
+            buildTable({
+                adapter: this,
+                disableNotNull: !!global.versions?.drafts,
+                disableUnique: true,
+                fields: versionFields,
+                locales,
+                tableName: versionsTableName,
+                timestamps: true,
+                versions: true
+            });
+        }
+    });
+};
+
+//# sourceMappingURL=init.js.map

package/dist/init.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/init.ts"],"sourcesContent":["/* eslint-disable no-param-reassign */\nimport type { DrizzleAdapter } from '@payloadcms/drizzle/types'\nimport type { Init, SanitizedCollectionConfig } from 'payload'\n\nimport { createTableName } from '@payloadcms/drizzle'\nimport { buildVersionCollectionFields, buildVersionGlobalFields } from 'payload'\nimport toSnakeCase from 'to-snake-case'\n\nimport type { SQLiteAdapter } from './types.js'\n\nimport { buildTable } from './schema/build.js'\n\nexport const init: Init = function init(this: SQLiteAdapter) {\n  let locales: [string, ...string[]] | undefined\n  if (this.payload.config.localization) {\n    locales = this.payload.config.localization.locales.map(({ code }) => code) as [\n      string,\n      ...string[],\n    ]\n  }\n\n  this.payload.config.collections.forEach((collection: SanitizedCollectionConfig) => {\n    createTableName({\n      adapter: this as unknown as DrizzleAdapter,\n      config: collection,\n    })\n\n    if (collection.versions) {\n      createTableName({\n        adapter: this as unknown as DrizzleAdapter,\n        config: collection,\n        versions: true,\n        versionsCustomName: true,\n      })\n    }\n  })\n  this.payload.config.collections.forEach((collection: SanitizedCollectionConfig) => {\n    const tableName = this.tableNameMap.get(toSnakeCase(collection.slug))\n\n    buildTable({\n      adapter: this,\n      disableNotNull: !!collection?.versions?.drafts,\n      disableUnique: false,\n      fields: collection.fields,\n      locales,\n      tableName,\n      timestamps: collection.timestamps,\n      versions: false,\n    })\n\n    if (collection.versions) {\n      const versionsTableName = this.tableNameMap.get(\n        `_${toSnakeCase(collection.slug)}${this.versionsSuffix}`,\n      )\n      const versionFields = buildVersionCollectionFields(collection)\n\n      buildTable({\n        adapter: this,\n        disableNotNull: !!collection.versions?.drafts,\n        disableUnique: true,\n        fields: versionFields,\n        locales,\n        tableName: versionsTableName,\n        timestamps: true,\n        versions: true,\n      })\n    }\n  })\n\n  this.payload.config.globals.forEach((global) => {\n    const tableName = createTableName({\n      adapter: this as unknown as DrizzleAdapter,\n      config: global,\n    })\n\n    buildTable({\n      adapter: this,\n      disableNotNull: !!global?.versions?.drafts,\n      disableUnique: false,\n      fields: global.fields,\n      locales,\n      tableName,\n      timestamps: false,\n      versions: false,\n    })\n\n    if (global.versions) {\n      const versionsTableName = createTableName({\n        adapter: this as unknown as DrizzleAdapter,\n        config: global,\n        versions: true,\n        versionsCustomName: true,\n      })\n      const versionFields = buildVersionGlobalFields(global)\n\n      buildTable({\n        adapter: this,\n        disableNotNull: !!global.versions?.drafts,\n        disableUnique: true,\n        fields: versionFields,\n        locales,\n        tableName: versionsTableName,\n        timestamps: true,\n        versions: true,\n      })\n    }\n  })\n}\n"],"names":["createTableName","buildVersionCollectionFields","buildVersionGlobalFields","toSnakeCase","buildTable","init","locales","payload","config","localization","map","code","collections","forEach","collection","adapter","versions","versionsCustomName","tableName","tableNameMap","get","slug","disableNotNull","drafts","disableUnique","fields","timestamps","versionsTableName","versionsSuffix","versionFields","globals","global"],"mappings":"AAAA,oCAAoC,GAIpC,SAASA,eAAe,QAAQ,sBAAqB;AACrD,SAASC,4BAA4B,EAAEC,wBAAwB,QAAQ,UAAS;AAChF,OAAOC,iBAAiB,gBAAe;AAIvC,SAASC,UAAU,QAAQ,oBAAmB;AAE9C,OAAO,MAAMC,OAAa,SAASA;IACjC,IAAIC;IACJ,IAAI,IAAI,CAACC,OAAO,CAACC,MAAM,CAACC,YAAY,EAAE;QACpCH,UAAU,IAAI,CAACC,OAAO,CAACC,MAAM,CAACC,YAAY,CAACH,OAAO,CAACI,GAAG,CAAC,CAAC,EAAEC,IAAI,EAAE,GAAKA;IAIvE;IAEA,IAAI,CAACJ,OAAO,CAACC,MAAM,CAACI,WAAW,CAACC,OAAO,CAAC,CAACC;QACvCd,gBAAgB;YACde,SAAS,IAAI;YACbP,QAAQM;QACV;QAEA,IAAIA,WAAWE,QAAQ,EAAE;YACvBhB,gBAAgB;gBACde,SAAS,IAAI;gBACbP,QAAQM;gBACRE,UAAU;gBACVC,oBAAoB;YACtB;QACF;IACF;IACA,IAAI,CAACV,OAAO,CAACC,MAAM,CAACI,WAAW,CAACC,OAAO,CAAC,CAACC;QACvC,MAAMI,YAAY,IAAI,CAACC,YAAY,CAACC,GAAG,CAACjB,YAAYW,WAAWO,IAAI;QAEnEjB,WAAW;YACTW,SAAS,IAAI;YACbO,gBAAgB,CAAC,CAACR,YAAYE,UAAUO;YACxCC,eAAe;YACfC,QAAQX,WAAWW,MAAM;YACzBnB;YACAY;YACAQ,YAAYZ,WAAWY,UAAU;YACjCV,UAAU;QACZ;QAEA,IAAIF,WAAWE,QAAQ,EAAE;YACvB,MAAMW,oBAAoB,IAAI,CAACR,YAAY,CAACC,GAAG,CAC7C,CAAC,CAAC,EAAEjB,YAAYW,WAAWO,IAAI,EAAE,EAAE,IAAI,CAACO,cAAc,CAAC,CAAC;YAE1D,MAAMC,gBAAgB5B,6BAA6Ba;YAEnDV,WAAW;gBACTW,SAAS,IAAI;gBACbO,gBAAgB,CAAC,CAACR,WAAWE,QAAQ,EAAEO;gBACvCC,eAAe;gBACfC,QAAQI;gBACRvB;gBACAY,WAAWS;gBACXD,YAAY;gBACZV,UAAU;YACZ;QACF;IACF;IAEA,IAAI,CAACT,OAAO,CAACC,MAAM,CAACsB,OAAO,CAACjB,OAAO,CAAC,CAACkB;QACnC,MAAMb,YAAYlB,gBAAgB;YAChCe,SAAS,IAAI;YACbP,QAAQuB;QACV;QAEA3B,WAAW;YACTW,SAAS,IAAI;YACbO,gBAAgB,CAAC,CAACS,QAAQf,UAAUO;YACpCC,eAAe;YACfC,QAAQM,OAAON,MAAM;YACrBnB;YACAY;YACAQ,YAAY;YACZV,UAAU;QACZ;QAEA,IAAIe,OAAOf,QAAQ,EAAE;YACnB,MAAMW,oBAAoB3B,gBAAgB;gBACxCe,SAAS,IAAI;gBACbP,QAAQuB;gBACRf,UAAU;gBACVC,oBAAoB;YACtB;YACA,MAAMY,gBAAgB3B,yBAAyB6B;YAE/C3B,WAAW;gBACTW,SAAS,IAAI;gBACbO,gBAAgB,CAAC,CAACS,OAAOf,QAAQ,EAAEO;gBACnCC,eAAe;gBACfC,QAAQI;gBACRvB;gBACAY,WAAWS;gBACXD,YAAY;gBACZV,UAAU;YACZ;QACF;IACF;AACF,EAAC"}

package/dist/insert.d.ts

@@ -0,0 +1,3 @@
+import type { Insert } from './types.js';
+export declare const insert: Insert;
+//# sourceMappingURL=insert.d.ts.map

package/dist/insert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"insert.d.ts","sourceRoot":"","sources":["../src/insert.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAExC,eAAO,MAAM,MAAM,EAAE,MAgBpB,CAAA"}

package/dist/insert.js

@@ -0,0 +1,13 @@
+export const insert = async function insert({ db, onConflictDoUpdate, tableName, values }) {
+    const table = this.tables[tableName];
+    let result;
+    if (onConflictDoUpdate) {
+        result = db.insert(table).values(values).onConflictDoUpdate(onConflictDoUpdate).returning();
+    } else {
+        result = db.insert(table).values(values).returning();
+    }
+    result = await result;
+    return result;
+};
+
+//# sourceMappingURL=insert.js.map

package/dist/insert.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/insert.ts"],"sourcesContent":["import type { Insert } from './types.js'\n\nexport const insert: Insert = async function insert({\n  db,\n  onConflictDoUpdate,\n  tableName,\n  values,\n}): Promise<Record<string, unknown>[]> {\n  const table = this.tables[tableName]\n  let result\n\n  if (onConflictDoUpdate) {\n    result = db.insert(table).values(values).onConflictDoUpdate(onConflictDoUpdate).returning()\n  } else {\n    result = db.insert(table).values(values).returning()\n  }\n  result = await result\n  return result\n}\n"],"names":["insert","db","onConflictDoUpdate","tableName","values","table","tables","result","returning"],"mappings":"AAEA,OAAO,MAAMA,SAAiB,eAAeA,OAAO,EAClDC,EAAE,EACFC,kBAAkB,EAClBC,SAAS,EACTC,MAAM,EACP;IACC,MAAMC,QAAQ,IAAI,CAACC,MAAM,CAACH,UAAU;IACpC,IAAII;IAEJ,IAAIL,oBAAoB;QACtBK,SAASN,GAAGD,MAAM,CAACK,OAAOD,MAAM,CAACA,QAAQF,kBAAkB,CAACA,oBAAoBM,SAAS;IAC3F,OAAO;QACLD,SAASN,GAAGD,MAAM,CAACK,OAAOD,MAAM,CAACA,QAAQI,SAAS;IACpD;IACAD,SAAS,MAAMA;IACf,OAAOA;AACT,EAAC"}

package/dist/requireDrizzleKit.d.ts

@@ -0,0 +1,6 @@
+import type { RequireDrizzleKit } from '@payloadcms/drizzle/types';
+/**
+ * Dynamically requires the `drizzle-kit` package to access the `generateSQLiteDrizzleJson` and `pushSQLiteSchema` functions and exports them generically to call them from @payloadcms/drizzle.
+ */
+export declare const requireDrizzleKit: RequireDrizzleKit;
+//# sourceMappingURL=requireDrizzleKit.d.ts.map

package/dist/requireDrizzleKit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requireDrizzleKit.d.ts","sourceRoot":"","sources":["../src/requireDrizzleKit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAA;AAKlE;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,iBAM/B,CAAA"}

package/dist/requireDrizzleKit.js

@@ -0,0 +1,13 @@
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+/**
+ * Dynamically requires the `drizzle-kit` package to access the `generateSQLiteDrizzleJson` and `pushSQLiteSchema` functions and exports them generically to call them from @payloadcms/drizzle.
+ */ export const requireDrizzleKit = ()=>{
+    const { generateSQLiteDrizzleJson: generateDrizzleJson, pushSQLiteSchema: pushSchema } = require('drizzle-kit/payload');
+    return {
+        generateDrizzleJson,
+        pushSchema
+    };
+};
+
+//# sourceMappingURL=requireDrizzleKit.js.map

package/dist/requireDrizzleKit.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/requireDrizzleKit.ts"],"sourcesContent":["import type { RequireDrizzleKit } from '@payloadcms/drizzle/types'\n\nimport { createRequire } from 'module'\nconst require = createRequire(import.meta.url)\n\n/**\n * Dynamically requires the `drizzle-kit` package to access the `generateSQLiteDrizzleJson` and `pushSQLiteSchema` functions and exports them generically to call them from @payloadcms/drizzle.\n */\nexport const requireDrizzleKit: RequireDrizzleKit = () => {\n  const {\n    generateSQLiteDrizzleJson: generateDrizzleJson,\n    pushSQLiteSchema: pushSchema,\n  } = require('drizzle-kit/payload')\n  return { generateDrizzleJson, pushSchema }\n}\n"],"names":["createRequire","require","url","requireDrizzleKit","generateSQLiteDrizzleJson","generateDrizzleJson","pushSQLiteSchema","pushSchema"],"mappings":"AAEA,SAASA,aAAa,QAAQ,SAAQ;AACtC,MAAMC,UAAUD,cAAc,YAAYE,GAAG;AAE7C;;CAEC,GACD,OAAO,MAAMC,oBAAuC;IAClD,MAAM,EACJC,2BAA2BC,mBAAmB,EAC9CC,kBAAkBC,UAAU,EAC7B,GAAGN,QAAQ;IACZ,OAAO;QAAEI;QAAqBE;IAAW;AAC3C,EAAC"}

package/dist/schema/build.d.ts

@@ -0,0 +1,49 @@
+import type { ColumnDataType } from 'drizzle-orm';
+import type { ForeignKeyBuilder, IndexBuilder, SQLiteColumn, SQLiteColumnBuilder, UniqueConstraintBuilder } from 'drizzle-orm/sqlite-core';
+import type { Field } from 'payload';
+import type { IDType, SQLiteAdapter } from '../types.js';
+export type BaseExtraConfig = Record<string, (cols: {
+    [x: string]: SQLiteColumn<{
+        baseColumn: never;
+        columnType: string;
+        data: unknown;
+        dataType: ColumnDataType;
+        driverParam: unknown;
+        enumValues: string[];
+        hasDefault: false;
+        name: string;
+        notNull: false;
+        tableName: string;
+    }>;
+}) => ForeignKeyBuilder | IndexBuilder | UniqueConstraintBuilder>;
+export type RelationMap = Map<string, {
+    localized: boolean;
+    target: string;
+    type: 'many' | 'one';
+}>;
+type Args = {
+    adapter: SQLiteAdapter;
+    baseColumns?: Record<string, SQLiteColumnBuilder>;
+    baseExtraConfig?: BaseExtraConfig;
+    buildNumbers?: boolean;
+    buildRelationships?: boolean;
+    disableNotNull: boolean;
+    disableUnique: boolean;
+    fields: Field[];
+    locales?: [string, ...string[]];
+    rootRelationsToBuild?: RelationMap;
+    rootRelationships?: Set<string>;
+    rootTableIDColType?: IDType;
+    rootTableName?: string;
+    tableName: string;
+    timestamps?: boolean;
+    versions: boolean;
+};
+type Result = {
+    hasManyNumberField: 'index' | boolean;
+    hasManyTextField: 'index' | boolean;
+    relationsToBuild: RelationMap;
+};
+export declare const buildTable: ({ adapter, baseColumns, baseExtraConfig, disableNotNull, disableUnique, fields, locales, rootRelationsToBuild, rootRelationships, rootTableIDColType, rootTableName: incomingRootTableName, tableName, timestamps, versions, }: 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":"AACA,OAAO,KAAK,EAAE,cAAc,EAAY,MAAM,aAAa,CAAA;AAC3D,OAAO,KAAK,EACV,iBAAiB,EACjB,YAAY,EACZ,YAAY,EACZ,mBAAmB,EAEnB,uBAAuB,EACxB,MAAM,yBAAyB,CAAA;AAChC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAepC,OAAO,KAAK,EAAgC,MAAM,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAMtF,MAAM,MAAM,eAAe,GAAG,MAAM,CAClC,MAAM,EACN,CAAC,IAAI,EAAE;IACL,CAAC,CAAC,EAAE,MAAM,GAAG,YAAY,CAAC;QACxB,UAAU,EAAE,KAAK,CAAA;QACjB,UAAU,EAAE,MAAM,CAAA;QAClB,IAAI,EAAE,OAAO,CAAA;QACb,QAAQ,EAAE,cAAc,CAAA;QACxB,WAAW,EAAE,OAAO,CAAA;QACpB,UAAU,EAAE,MAAM,EAAE,CAAA;QACpB,UAAU,EAAE,KAAK,CAAA;QACjB,IAAI,EAAE,MAAM,CAAA;QACZ,OAAO,EAAE,KAAK,CAAA;QACd,SAAS,EAAE,MAAM,CAAA;KAClB,CAAC,CAAA;CACH,KAAK,iBAAiB,GAAG,YAAY,GAAG,uBAAuB,CACjE,CAAA;AAED,MAAM,MAAM,WAAW,GAAG,GAAG,CAAC,MAAM,EAAE;IAAE,SAAS,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,GAAG,KAAK,CAAA;CAAE,CAAC,CAAA;AAEnG,KAAK,IAAI,GAAG;IACV,OAAO,EAAE,aAAa,CAAA;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAA;IACjD,eAAe,CAAC,EAAE,eAAe,CAAA;IACjC,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,kBAAkB,CAAC,EAAE,OAAO,CAAA;IAC5B,cAAc,EAAE,OAAO,CAAA;IACvB,aAAa,EAAE,OAAO,CAAA;IACtB,MAAM,EAAE,KAAK,EAAE,CAAA;IACf,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,CAAA;IAC/B,oBAAoB,CAAC,EAAE,WAAW,CAAA;IAClC,iBAAiB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAC/B,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,QAAQ,EAAE,OAAO,CAAA;CAClB,CAAA;AAED,KAAK,MAAM,GAAG;IACZ,kBAAkB,EAAE,OAAO,GAAG,OAAO,CAAA;IACrC,gBAAgB,EAAE,OAAO,GAAG,OAAO,CAAA;IACnC,gBAAgB,EAAE,WAAW,CAAA;CAC9B,CAAA;AAED,eAAO,MAAM,UAAU,mOAepB,IAAI,KAAG,MA8YT,CAAA"}

package/dist/schema/build.js

@@ -0,0 +1,407 @@
+/* eslint-disable no-param-reassign */ import { createTableName } from '@payloadcms/drizzle';
+import { relations, sql } from 'drizzle-orm';
+import { foreignKey, index, integer, numeric, sqliteTable, text, unique } from 'drizzle-orm/sqlite-core';
+import toSnakeCase from 'to-snake-case';
+import { getIDColumn } from './getIDColumn.js';
+import { setColumnID } from './setColumnID.js';
+import { traverseFields } from './traverseFields.js';
+export const buildTable = ({ adapter, baseColumns = {}, baseExtraConfig = {}, disableNotNull, disableUnique = false, fields, locales, rootRelationsToBuild, rootRelationships, rootTableIDColType, rootTableName: incomingRootTableName, tableName, timestamps, versions })=>{
+    const isRoot = !incomingRootTableName;
+    const rootTableName = incomingRootTableName || tableName;
+    const columns = baseColumns;
+    const indexes = {};
+    const localesColumns = {};
+    const localesIndexes = {};
+    let localesTable;
+    let textsTable;
+    let numbersTable;
+    // Relationships to the base collection
+    const relationships = rootRelationships || new Set();
+    let relationshipsTable;
+    // Drizzle relations
+    const relationsToBuild = new Map();
+    const idColType = setColumnID({
+        columns,
+        fields
+    });
+    const { hasLocalizedField, hasLocalizedManyNumberField, hasLocalizedManyTextField, hasLocalizedRelationshipField, hasManyNumberField, hasManyTextField } = traverseFields({
+        adapter,
+        columns,
+        disableNotNull,
+        disableUnique,
+        fields,
+        indexes,
+        locales,
+        localesColumns,
+        localesIndexes,
+        newTableName: tableName,
+        parentTableName: tableName,
+        relationsToBuild,
+        relationships,
+        rootRelationsToBuild: rootRelationsToBuild || relationsToBuild,
+        rootTableIDColType: rootTableIDColType || idColType,
+        rootTableName,
+        versions
+    });
+    // split the relationsToBuild by localized and non-localized
+    const localizedRelations = new Map();
+    const nonLocalizedRelations = new Map();
+    relationsToBuild.forEach(({ type, localized, target }, key)=>{
+        const map = localized ? localizedRelations : nonLocalizedRelations;
+        map.set(key, {
+            type,
+            target
+        });
+    });
+    if (timestamps) {
+        columns.createdAt = text('created_at').default(sql`(strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))`).notNull();
+        columns.updatedAt = text('updated_at').default(sql`(strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))`).notNull();
+    }
+    const table = sqliteTable(tableName, columns, (cols)=>{
+        const extraConfig = Object.entries(baseExtraConfig).reduce((config, [key, func])=>{
+            config[key] = func(cols);
+            return config;
+        }, {});
+        const result = Object.entries(indexes).reduce((acc, [colName, func])=>{
+            acc[colName] = func(cols);
+            return acc;
+        }, extraConfig);
+        return result;
+    });
+    adapter.tables[tableName] = table;
+    if (hasLocalizedField || localizedRelations.size) {
+        const localeTableName = `${tableName}${adapter.localesSuffix}`;
+        localesColumns.id = integer('id', {
+            mode: 'number'
+        }).primaryKey({
+            autoIncrement: true
+        });
+        localesColumns._locale = text('_locale', {
+            enum: locales
+        }).notNull();
+        localesColumns._parentID = getIDColumn({
+            name: '_parent_id',
+            type: idColType,
+            notNull: true,
+            primaryKey: false
+        });
+        localesTable = sqliteTable(localeTableName, localesColumns, (cols)=>{
+            return Object.entries(localesIndexes).reduce((acc, [colName, func])=>{
+                acc[colName] = func(cols);
+                return acc;
+            }, {
+                _localeParent: unique(`${localeTableName}_locale_parent_id_unique`).on(cols._locale, cols._parentID),
+                _parentIdFk: foreignKey({
+                    name: `${localeTableName}_parent_id_fk`,
+                    columns: [
+                        cols._parentID
+                    ],
+                    foreignColumns: [
+                        table.id
+                    ]
+                }).onDelete('cascade')
+            });
+        });
+        adapter.tables[localeTableName] = localesTable;
+        adapter.relations[`relations_${localeTableName}`] = relations(localesTable, ({ many, one })=>{
+            const result = {};
+            result._parentID = one(table, {
+                fields: [
+                    localesTable._parentID
+                ],
+                references: [
+                    table.id
+                ],
+                // name the relationship by what the many() relationName is
+                relationName: '_locales'
+            });
+            localizedRelations.forEach(({ type, target }, key)=>{
+                if (type === 'one') {
+                    result[key] = one(adapter.tables[target], {
+                        fields: [
+                            localesTable[key]
+                        ],
+                        references: [
+                            adapter.tables[target].id
+                        ],
+                        relationName: key
+                    });
+                }
+                if (type === 'many') {
+                    result[key] = many(adapter.tables[target], {
+                        relationName: key
+                    });
+                }
+            });
+            return result;
+        });
+    }
+    if (isRoot) {
+        if (hasManyTextField) {
+            const textsTableName = `${rootTableName}_texts`;
+            const columns = {
+                id: integer('id', {
+                    mode: 'number'
+                }).primaryKey({
+                    autoIncrement: true
+                }),
+                order: integer('order').notNull(),
+                parent: getIDColumn({
+                    name: 'parent_id',
+                    type: idColType,
+                    notNull: true,
+                    primaryKey: false
+                }),
+                path: text('path').notNull(),
+                text: text('text')
+            };
+            if (hasLocalizedManyTextField) {
+                columns.locale = text('locale', {
+                    enum: locales
+                });
+            }
+            textsTable = sqliteTable(textsTableName, columns, (cols)=>{
+                const config = {
+                    orderParentIdx: index(`${textsTableName}_order_parent_idx`).on(cols.order, cols.parent),
+                    parentFk: foreignKey({
+                        name: `${textsTableName}_parent_fk`,
+                        columns: [
+                            cols.parent
+                        ],
+                        foreignColumns: [
+                            table.id
+                        ]
+                    }).onDelete('cascade')
+                };
+                if (hasManyTextField === 'index') {
+                    config.text_idx = index(`${textsTableName}_text_idx`).on(cols.text);
+                }
+                if (hasLocalizedManyTextField) {
+                    config.localeParent = index(`${textsTableName}_locale_parent`).on(cols.locale, cols.parent);
+                }
+                return config;
+            });
+            adapter.tables[textsTableName] = textsTable;
+            adapter.relations[`relations_${textsTableName}`] = relations(textsTable, ({ one })=>({
+                    parent: one(table, {
+                        fields: [
+                            textsTable.parent
+                        ],
+                        references: [
+                            table.id
+                        ],
+                        relationName: '_texts'
+                    })
+                }));
+        }
+        if (hasManyNumberField) {
+            const numbersTableName = `${rootTableName}_numbers`;
+            const columns = {
+                id: integer('id', {
+                    mode: 'number'
+                }).primaryKey({
+                    autoIncrement: true
+                }),
+                number: numeric('number'),
+                order: integer('order').notNull(),
+                parent: getIDColumn({
+                    name: 'parent_id',
+                    type: idColType,
+                    notNull: true,
+                    primaryKey: false
+                }),
+                path: text('path').notNull()
+            };
+            if (hasLocalizedManyNumberField) {
+                columns.locale = text('locale', {
+                    enum: locales
+                });
+            }
+            numbersTable = sqliteTable(numbersTableName, columns, (cols)=>{
+                const config = {
+                    orderParentIdx: index(`${numbersTableName}_order_parent_idx`).on(cols.order, cols.parent),
+                    parentFk: foreignKey({
+                        name: `${numbersTableName}_parent_fk`,
+                        columns: [
+                            cols.parent
+                        ],
+                        foreignColumns: [
+                            table.id
+                        ]
+                    }).onDelete('cascade')
+                };
+                if (hasManyNumberField === 'index') {
+                    config.numberIdx = index(`${numbersTableName}_number_idx`).on(cols.number);
+                }
+                if (hasLocalizedManyNumberField) {
+                    config.localeParent = index(`${numbersTableName}_locale_parent`).on(cols.locale, cols.parent);
+                }
+                return config;
+            });
+            adapter.tables[numbersTableName] = numbersTable;
+            adapter.relations[`relations_${numbersTableName}`] = relations(numbersTable, ({ one })=>({
+                    parent: one(table, {
+                        fields: [
+                            numbersTable.parent
+                        ],
+                        references: [
+                            table.id
+                        ],
+                        relationName: '_numbers'
+                    })
+                }));
+        }
+        if (relationships.size) {
+            const relationshipColumns = {
+                id: integer('id', {
+                    mode: 'number'
+                }).primaryKey({
+                    autoIncrement: true
+                }),
+                order: integer('order'),
+                parent: getIDColumn({
+                    name: 'parent_id',
+                    type: idColType,
+                    notNull: true,
+                    primaryKey: false
+                }),
+                path: text('path').notNull()
+            };
+            if (hasLocalizedRelationshipField) {
+                relationshipColumns.locale = text('locale', {
+                    enum: locales
+                });
+            }
+            const relationExtraConfig = {};
+            const relationshipsTableName = `${tableName}${adapter.relationshipsSuffix}`;
+            relationships.forEach((relationTo)=>{
+                const relationshipConfig = adapter.payload.collections[relationTo].config;
+                const formattedRelationTo = createTableName({
+                    adapter,
+                    config: relationshipConfig
+                });
+                let colType = 'integer';
+                const relatedCollectionCustomIDType = adapter.payload.collections[relationshipConfig.slug]?.customIDType;
+                if (relatedCollectionCustomIDType === 'number') colType = 'numeric';
+                if (relatedCollectionCustomIDType === 'text') colType = 'text';
+                relationshipColumns[`${relationTo}ID`] = getIDColumn({
+                    name: `${formattedRelationTo}_id`,
+                    type: colType,
+                    primaryKey: false
+                });
+                relationExtraConfig[`${relationTo}IdFk`] = (cols)=>foreignKey({
+                        name: `${relationshipsTableName}_${toSnakeCase(relationTo)}_fk`,
+                        columns: [
+                            cols[`${relationTo}ID`]
+                        ],
+                        foreignColumns: [
+                            adapter.tables[formattedRelationTo].id
+                        ]
+                    }).onDelete('cascade');
+            });
+            relationshipsTable = sqliteTable(relationshipsTableName, relationshipColumns, (cols)=>{
+                const result = Object.entries(relationExtraConfig).reduce((config, [key, func])=>{
+                    config[key] = func(cols);
+                    return config;
+                }, {
+                    order: index(`${relationshipsTableName}_order_idx`).on(cols.order),
+                    parentFk: foreignKey({
+                        name: `${relationshipsTableName}_parent_fk`,
+                        columns: [
+                            cols.parent
+                        ],
+                        foreignColumns: [
+                            table.id
+                        ]
+                    }).onDelete('cascade'),
+                    parentIdx: index(`${relationshipsTableName}_parent_idx`).on(cols.parent),
+                    pathIdx: index(`${relationshipsTableName}_path_idx`).on(cols.path)
+                });
+                if (hasLocalizedRelationshipField) {
+                    result.localeIdx = index(`${relationshipsTableName}_locale_idx`).on(cols.locale);
+                }
+                return result;
+            });
+            adapter.tables[relationshipsTableName] = relationshipsTable;
+            adapter.relations[`relations_${relationshipsTableName}`] = relations(relationshipsTable, ({ one })=>{
+                const result = {
+                    parent: one(table, {
+                        fields: [
+                            relationshipsTable.parent
+                        ],
+                        references: [
+                            table.id
+                        ],
+                        relationName: '_rels'
+                    })
+                };
+                relationships.forEach((relationTo)=>{
+                    const relatedTableName = createTableName({
+                        adapter,
+                        config: adapter.payload.collections[relationTo].config
+                    });
+                    const idColumnName = `${relationTo}ID`;
+                    result[idColumnName] = one(adapter.tables[relatedTableName], {
+                        fields: [
+                            relationshipsTable[idColumnName]
+                        ],
+                        references: [
+                            adapter.tables[relatedTableName].id
+                        ],
+                        relationName: relationTo
+                    });
+                });
+                return result;
+            });
+        }
+    }
+    adapter.relations[`relations_${tableName}`] = relations(table, ({ many, one })=>{
+        const result = {};
+        nonLocalizedRelations.forEach(({ type, target }, key)=>{
+            if (type === 'one') {
+                result[key] = one(adapter.tables[target], {
+                    fields: [
+                        table[key]
+                    ],
+                    references: [
+                        adapter.tables[target].id
+                    ],
+                    relationName: key
+                });
+            }
+            if (type === 'many') {
+                result[key] = many(adapter.tables[target], {
+                    relationName: key
+                });
+            }
+        });
+        if (hasLocalizedField) {
+            result._locales = many(localesTable, {
+                relationName: '_locales'
+            });
+        }
+        if (hasManyTextField) {
+            result._texts = many(textsTable, {
+                relationName: '_texts'
+            });
+        }
+        if (hasManyNumberField) {
+            result._numbers = many(numbersTable, {
+                relationName: '_numbers'
+            });
+        }
+        if (relationships.size && relationshipsTable) {
+            result._rels = many(relationshipsTable, {
+                relationName: '_rels'
+            });
+        }
+        return result;
+    });
+    return {
+        hasManyNumberField,
+        hasManyTextField,
+        relationsToBuild
+    };
+};
+
+//# sourceMappingURL=build.js.map