Marc Mintel
5397309103
Some checks failed
Build & Deploy / 🔍 Prepare (push) Successful in 20s
Build & Deploy / 🧪 QA (push) Failing after 34s
Build & Deploy / 🏗️ Build (push) Has started running
Build & Deploy / 🚀 Deploy (push) Has been cancelled
Build & Deploy / 🧪 Smoke Test (push) Has been cancelled
Build & Deploy / ⚡ Lighthouse (push) Has been cancelled
Build & Deploy / 🔔 Notify (push) Has been cancelled
334 lines
12 KiB
Plaintext
334 lines
12 KiB
Plaintext
import type { Column, ColumnBaseConfig, ColumnDataType, DrizzleConfig, ExtractTablesWithRelations, Relation, Relations, SQL, TableRelationalConfig } from 'drizzle-orm';
|
|
import type { LibSQLDatabase } from 'drizzle-orm/libsql';
|
|
import type { NodePgDatabase, NodePgQueryResultHKT } from 'drizzle-orm/node-postgres';
|
|
import type { PgColumn, PgTable, PgTransaction, Precision, UpdateDeleteAction } from 'drizzle-orm/pg-core';
|
|
import type { SQLiteColumn, SQLiteTable, SQLiteTransaction } from 'drizzle-orm/sqlite-core';
|
|
import type { Result } from 'drizzle-orm/sqlite-core/session';
|
|
import type { BaseDatabaseAdapter, FlattenedField, MigrationData, Payload, PayloadRequest } from 'payload';
|
|
import type { BuildQueryJoinAliases } from './queries/buildQuery.js';
|
|
export { BuildQueryJoinAliases };
|
|
import type { ResultSet } from '@libsql/client';
|
|
import type { DrizzleSnapshotJSON } from 'drizzle-kit/api';
|
|
import type { SQLiteRaw } from 'drizzle-orm/sqlite-core/query-builders/raw';
|
|
import type { QueryResult } from 'pg';
|
|
import type { Operators } from './queries/operatorMap.js';
|
|
export type PostgresDB = NodePgDatabase<Record<string, unknown>>;
|
|
export type SQLiteDB = LibSQLDatabase<Record<string, GenericRelation | GenericTable> & Record<string, unknown>>;
|
|
export type GenericPgColumn = PgColumn<ColumnBaseConfig<ColumnDataType, string>, Record<string, unknown>>;
|
|
export type GenericColumns<T> = {
|
|
[x: string]: T;
|
|
};
|
|
type GenericPgTable = PgTable<{
|
|
columns: GenericColumns<GenericPgColumn>;
|
|
dialect: string;
|
|
name: string;
|
|
schema: undefined;
|
|
}>;
|
|
type GenericSQLiteTable = SQLiteTable<{
|
|
columns: GenericColumns<SQLiteColumn>;
|
|
dialect: string;
|
|
name: string;
|
|
schema: undefined;
|
|
}>;
|
|
export type GenericColumn = GenericPgColumn | SQLiteColumn;
|
|
export type GenericTable = GenericPgTable | GenericSQLiteTable;
|
|
export type GenericRelation = Relations<string, Record<string, Relation<string>>>;
|
|
export type TransactionSQLite = SQLiteTransaction<'async', Result<'async', unknown>, Record<string, unknown>, {
|
|
tsName: TableRelationalConfig;
|
|
}>;
|
|
export type TransactionPg = PgTransaction<NodePgQueryResultHKT, Record<string, unknown>, ExtractTablesWithRelations<Record<string, unknown>>>;
|
|
export type DrizzleTransaction = TransactionPg | TransactionSQLite;
|
|
export type CountDistinct = (args: {
|
|
column?: PgColumn<any> | SQLiteColumn<any>;
|
|
db: DrizzleTransaction | LibSQLDatabase | PostgresDB;
|
|
joins: BuildQueryJoinAliases;
|
|
tableName: string;
|
|
where: SQL;
|
|
}) => Promise<number>;
|
|
export type DeleteWhere = (args: {
|
|
db: DrizzleTransaction | LibSQLDatabase | PostgresDB;
|
|
tableName: string;
|
|
where: SQL;
|
|
}) => Promise<void>;
|
|
export type DropDatabase = (args: {
|
|
adapter: DrizzleAdapter;
|
|
}) => Promise<void>;
|
|
export type Execute<T> = (args: {
|
|
db?: DrizzleTransaction | LibSQLDatabase | PostgresDB;
|
|
drizzle?: LibSQLDatabase | PostgresDB;
|
|
raw?: string;
|
|
sql?: SQL<unknown>;
|
|
}) => Promise<QueryResult<Record<string, T>>> | SQLiteRaw<Promise<{
|
|
rows: T[];
|
|
}>> | SQLiteRaw<ResultSet>;
|
|
export type Insert = (args: {
|
|
db: DrizzleTransaction | LibSQLDatabase | PostgresDB;
|
|
onConflictDoUpdate?: unknown;
|
|
tableName: string;
|
|
values: Record<string, unknown> | Record<string, unknown>[];
|
|
}) => Promise<Record<string, unknown>[]>;
|
|
export type RequireDrizzleKit = () => {
|
|
generateDrizzleJson: (args: Record<string, unknown>) => DrizzleSnapshotJSON | Promise<DrizzleSnapshotJSON>;
|
|
generateMigration: (prev: DrizzleSnapshotJSON, cur: DrizzleSnapshotJSON) => Promise<string[]>;
|
|
pushSchema: (schema: Record<string, unknown>, drizzle: DrizzleAdapter['drizzle'], filterSchema?: string[], tablesFilter?: string[], extensionsFilter?: string[]) => Promise<{
|
|
apply: any;
|
|
hasDataLoss: any;
|
|
warnings: any;
|
|
}>;
|
|
upSnapshot?: (snapshot: Record<string, unknown>) => DrizzleSnapshotJSON;
|
|
};
|
|
export type Migration = {
|
|
down: ({ db, payload, req, }: {
|
|
db?: DrizzleTransaction | LibSQLDatabase<Record<string, never>> | PostgresDB;
|
|
payload: Payload;
|
|
req: PayloadRequest;
|
|
}) => Promise<void>;
|
|
up: ({ db, payload, req, }: {
|
|
db?: DrizzleTransaction | LibSQLDatabase | PostgresDB;
|
|
payload: Payload;
|
|
req: PayloadRequest;
|
|
}) => Promise<void>;
|
|
} & MigrationData;
|
|
export type CreateJSONQueryArgs = {
|
|
column?: Column | string;
|
|
operator: string;
|
|
pathSegments: string[];
|
|
rawColumn?: SQL<unknown>;
|
|
table?: string;
|
|
treatAsArray?: string[];
|
|
treatRootAsArray?: boolean;
|
|
value: boolean | number | number[] | string | string[];
|
|
};
|
|
/**
|
|
* Abstract relation link
|
|
*/
|
|
export type RawRelation = {
|
|
fields: {
|
|
name: string;
|
|
table: string;
|
|
}[];
|
|
references: string[];
|
|
relationName?: string;
|
|
to: string;
|
|
type: 'one';
|
|
} | {
|
|
relationName?: string;
|
|
to: string;
|
|
type: 'many';
|
|
};
|
|
/**
|
|
* Abstract SQL table that later gets converted by database specific implementation to Drizzle
|
|
*/
|
|
export type RawTable = {
|
|
columns: Record<string, RawColumn>;
|
|
foreignKeys?: Record<string, RawForeignKey>;
|
|
indexes?: Record<string, RawIndex>;
|
|
name: string;
|
|
};
|
|
/**
|
|
* Abstract SQL foreign key that later gets converted by database specific implementation to Drizzle
|
|
*/
|
|
export type RawForeignKey = {
|
|
columns: string[];
|
|
foreignColumns: {
|
|
name: string;
|
|
table: string;
|
|
}[];
|
|
name: string;
|
|
onDelete?: UpdateDeleteAction;
|
|
onUpdate?: UpdateDeleteAction;
|
|
};
|
|
/**
|
|
* Abstract SQL index that later gets converted by database specific implementation to Drizzle
|
|
*/
|
|
export type RawIndex = {
|
|
name: string;
|
|
on: string | string[];
|
|
unique?: boolean;
|
|
};
|
|
/**
|
|
* Abstract SQL column that later gets converted by database specific implementation to Drizzle
|
|
*/
|
|
export type BaseRawColumn = {
|
|
default?: any;
|
|
name: string;
|
|
notNull?: boolean;
|
|
primaryKey?: boolean;
|
|
reference?: {
|
|
name: string;
|
|
onDelete: UpdateDeleteAction;
|
|
table: string;
|
|
};
|
|
};
|
|
/**
|
|
* Postgres: native timestamp type
|
|
* SQLite: text column, defaultNow achieved through strftime('%Y-%m-%dT%H:%M:%fZ', 'now'). withTimezone/precision have no any effect.
|
|
*/
|
|
export type TimestampRawColumn = {
|
|
defaultNow?: boolean;
|
|
mode: 'date' | 'string';
|
|
precision: Precision;
|
|
type: 'timestamp';
|
|
withTimezone?: boolean;
|
|
} & BaseRawColumn;
|
|
/**
|
|
* Postgres: native UUID type and db lavel defaultRandom
|
|
* SQLite: text type and defaultRandom in the app level
|
|
*/
|
|
export type UUIDRawColumn = {
|
|
defaultRandom?: boolean;
|
|
type: 'uuid';
|
|
} & BaseRawColumn;
|
|
/**
|
|
* Accepts either `locale: true` to have options from locales or `options` string array
|
|
* Postgres: native enums
|
|
* SQLite: text column with checks.
|
|
*/
|
|
export type EnumRawColumn = ({
|
|
enumName: string;
|
|
options: string[];
|
|
type: 'enum';
|
|
} | {
|
|
locale: true;
|
|
type: 'enum';
|
|
}) & BaseRawColumn;
|
|
export type IntegerRawColumn = {
|
|
/**
|
|
* SQLite only.
|
|
* Enable [AUTOINCREMENT](https://www.sqlite.org/autoinc.html) for primary key to ensure that the same ID cannot be reused from previously deleted rows.
|
|
*/
|
|
autoIncrement?: boolean;
|
|
type: 'integer';
|
|
} & BaseRawColumn;
|
|
export type VectorRawColumn = {
|
|
dimensions?: number;
|
|
type: 'vector';
|
|
} & BaseRawColumn;
|
|
export type HalfVecRawColumn = {
|
|
dimensions?: number;
|
|
type: 'halfvec';
|
|
} & BaseRawColumn;
|
|
export type SparseVecRawColumn = {
|
|
dimensions?: number;
|
|
type: 'sparsevec';
|
|
} & BaseRawColumn;
|
|
export type BinaryVecRawColumn = {
|
|
dimensions?: number;
|
|
type: 'bit';
|
|
} & BaseRawColumn;
|
|
export type RawColumn = ({
|
|
type: 'boolean' | 'geometry' | 'jsonb' | 'numeric' | 'serial' | 'text' | 'varchar';
|
|
} & BaseRawColumn) | BinaryVecRawColumn | EnumRawColumn | HalfVecRawColumn | IntegerRawColumn | SparseVecRawColumn | TimestampRawColumn | UUIDRawColumn | VectorRawColumn;
|
|
export type IDType = 'integer' | 'numeric' | 'text' | 'uuid' | 'varchar';
|
|
export type SetColumnID = (args: {
|
|
adapter: DrizzleAdapter;
|
|
columns: Record<string, RawColumn>;
|
|
fields: FlattenedField[];
|
|
}) => IDType;
|
|
export type ColumnToCodeConverter = (args: {
|
|
adapter: DrizzleAdapter;
|
|
addEnum: (name: string, options: string[]) => void;
|
|
addImport: (from: string, name: string) => void;
|
|
column: RawColumn;
|
|
locales?: string[];
|
|
tableKey: string;
|
|
}) => string;
|
|
export type BuildDrizzleTable<T extends DrizzleAdapter = DrizzleAdapter> = (args: {
|
|
adapter: T;
|
|
locales: string[];
|
|
rawTable: RawTable;
|
|
}) => void;
|
|
export type BlocksToJsonBlockToMigrate = {
|
|
data: Record<string, unknown> | Record<string, unknown>[];
|
|
fieldAccessor: (number | string)[];
|
|
};
|
|
export interface BaseBlocksToJsonEntityToMigrate {
|
|
blocks: BlocksToJsonBlockToMigrate[];
|
|
originalData: Record<string, any>;
|
|
}
|
|
export interface CollectionOrVersionBlocksToJsonEntityToMigrate extends BaseBlocksToJsonEntityToMigrate {
|
|
id: number | string;
|
|
slug: string;
|
|
type: 'collection' | 'collectionVersion' | 'globalVersion';
|
|
}
|
|
export interface GlobalBlocksToJsonEntityToMigrate extends BaseBlocksToJsonEntityToMigrate {
|
|
slug: string;
|
|
type: 'global';
|
|
}
|
|
export type BlocksToJsonEntityToMigrate = CollectionOrVersionBlocksToJsonEntityToMigrate | GlobalBlocksToJsonEntityToMigrate;
|
|
export interface BlocksToJsonMigrator {
|
|
collectAndSaveEntitiesToBatches(req: PayloadRequest, options?: {
|
|
batchSize?: number;
|
|
}): Promise<void>;
|
|
getMigrationStatements(): Promise<{
|
|
statements: string;
|
|
writeDrizzleSnapshot(filePath: string): void;
|
|
}>;
|
|
migrateEntitiesFromTempFolder(req: PayloadRequest, options?: {
|
|
clearBatches?: boolean;
|
|
}): Promise<void>;
|
|
setTempFolder(tempFolderPath: string): void;
|
|
updatePayloadConfigFile(): Promise<void>;
|
|
}
|
|
export interface DrizzleAdapter extends BaseDatabaseAdapter {
|
|
blocksAsJSON?: boolean;
|
|
blocksToJsonMigrator?: BlocksToJsonMigrator;
|
|
convertPathToJSONTraversal?: (incomingSegments: string[]) => string;
|
|
countDistinct: CountDistinct;
|
|
createJSONQuery: (args: CreateJSONQueryArgs) => string;
|
|
defaultDrizzleSnapshot: Record<string, unknown>;
|
|
deleteWhere: DeleteWhere;
|
|
drizzle: LibSQLDatabase | PostgresDB;
|
|
dropDatabase: DropDatabase;
|
|
enums?: never | Record<string, unknown>;
|
|
execute: Execute<unknown>;
|
|
features: {
|
|
json?: boolean;
|
|
};
|
|
/**
|
|
* An object keyed on each table, with a key value pair where the constraint name is the key, followed by the dot-notation field name
|
|
* Used for returning properly formed errors from unique fields
|
|
*/
|
|
fieldConstraints: Record<string, Record<string, string>>;
|
|
foreignKeys: Set<string>;
|
|
idType: 'serial' | 'uuid';
|
|
indexes: Set<string>;
|
|
initializing: Promise<void>;
|
|
insert: Insert;
|
|
limitedBoundParameters?: boolean;
|
|
localesSuffix?: string;
|
|
logger: DrizzleConfig['logger'];
|
|
operators: Operators;
|
|
push: boolean;
|
|
rawRelations: Record<string, Record<string, RawRelation>>;
|
|
rawTables: Record<string, RawTable>;
|
|
rejectInitializing: () => void;
|
|
relations: Record<string, GenericRelation>;
|
|
relationshipsSuffix?: string;
|
|
requireDrizzleKit: RequireDrizzleKit;
|
|
resolveInitializing: () => void;
|
|
schema: Record<string, unknown>;
|
|
schemaName?: string;
|
|
sessions: {
|
|
[id: string]: {
|
|
db: DrizzleTransaction;
|
|
reject: () => Promise<void>;
|
|
resolve: () => Promise<void>;
|
|
};
|
|
};
|
|
tableNameMap: Map<string, string>;
|
|
tables: Record<string, any>;
|
|
transactionOptions: unknown;
|
|
versionsSuffix?: string;
|
|
}
|
|
export type RelationMap = Map<string, {
|
|
localized: boolean;
|
|
relationName?: string;
|
|
target: string;
|
|
type: 'many' | 'one';
|
|
}>;
|
|
/**
|
|
* @deprecated - will be removed in 4.0. Use query + $dynamic() instead: https://orm.drizzle.team/docs/dynamic-query-building
|
|
*/
|
|
export type { ChainedMethods } from './find/chainMethods.js';
|
|
//# sourceMappingURL=types.d.ts.map |