SQLiteD1Session Class — drizzle-orm Architecture

Source Code

drizzle-orm/src/d1/session.ts lines 30–126

export class SQLiteD1Session<
	TFullSchema extends Record<string, unknown>,
	TSchema extends TablesRelationalConfig,
> extends SQLiteSession<'async', D1Result, TFullSchema, TSchema> {
	static override readonly [entityKind]: string = 'SQLiteD1Session';

	private logger: Logger;
	private cache: Cache;

	constructor(
		private client: D1Database,
		dialect: SQLiteAsyncDialect,
		private schema: RelationalSchemaConfig<TSchema> | undefined,
		private options: SQLiteD1SessionOptions = {},
	) {
		super(dialect);
		this.logger = options.logger ?? new NoopLogger();
		this.cache = options.cache ?? new NoopCache();
	}

	prepareQuery(
		query: Query,
		fields: SelectedFieldsOrdered | undefined,
		executeMethod: SQLiteExecuteMethod,
		isResponseInArrayMode: boolean,
		customResultMapper?: (rows: unknown[][]) => unknown,
		queryMetadata?: {
			type: 'select' | 'update' | 'delete' | 'insert';
			tables: string[];
		},
		cacheConfig?: WithCacheConfig,
	): D1PreparedQuery {
		const stmt = this.client.prepare(query.sql);
		return new D1PreparedQuery(
			stmt,
			query,
			this.logger,
			this.cache,
			queryMetadata,
			cacheConfig,
			fields,
			executeMethod,
			isResponseInArrayMode,
			customResultMapper,
		);
	}

	async batch<T extends BatchItem<'sqlite'>[] | readonly BatchItem<'sqlite'>[]>(queries: T) {
		const preparedQueries: PreparedQuery[] = [];
		const builtQueries: D1PreparedStatement[] = [];

		for (const query of queries) {
			const preparedQuery = query._prepare();
			const builtQuery = preparedQuery.getQuery();
			preparedQueries.push(preparedQuery);
			if (builtQuery.params.length > 0) {
				builtQueries.push((preparedQuery as D1PreparedQuery).stmt.bind(...builtQuery.params));
			} else {
				const builtQuery = preparedQuery.getQuery();
				builtQueries.push(
					this.client.prepare(builtQuery.sql).bind(...builtQuery.params),
				);
			}
		}

		const batchResults = await this.client.batch<any>(builtQueries);
		return batchResults.map((result, i) => preparedQueries[i]!.mapResult(result, true));
	}

	override extractRawAllValueFromBatchResult(result: unknown): unknown {
		return (result as D1Result).results;
	}

	override extractRawGetValueFromBatchResult(result: unknown): unknown {
		return (result as D1Result).results[0];
	}

	override extractRawValuesValueFromBatchResult(result: unknown): unknown {
		return d1ToRawMapping((result as D1Result).results);
	}