Query Caching

Copyexport abstract class Cache {
	static readonly [entityKind]: string = 'Cache';
 
	abstract strategy(): 'explicit' | 'all';
 
	/**
	 * Invoked if we should check cache for cached response
	 * @param sql
	 * @param tables
	 */
	abstract get(
		key: string,
		tables: string[],
		isTag: boolean,
		isAutoInvalidate?: boolean,
	): Promise<any[] | undefined>;
 
	/**
	 * Invoked if new query should be inserted to cache
	 * @param sql
	 * @param tables
	 */
	abstract put(
		hashedQuery: string,
		response: any,
		tables: string[],
		isTag: boolean,
		config?: CacheConfig,
	): Promise<void>;
 
	/**
	 * Invoked if insert, update, delete was invoked
	 * @param tables
	 */
	abstract onMutate(
		params: MutationOption,
	): Promise<void>;
}
 
export class NoopCache extends Cache {
	override strategy() {
		return 'all' as const;
	}
 
	static override readonly [entityKind]: string = 'NoopCache';
 
	override async get(_key: string): Promise<any[] | undefined> {
		return undefined;
	}
	override async put(
		_hashedQuery: string,
		_response: any,
		_tables: string[],
		_config?: any,
	): Promise<void> {
		// noop
	}
	override async onMutate(_params: MutationOption): Promise<void> {
		// noop
	}
}

Copyexport type MutationOption = { tags?: string | string[]; tables?: Table<any> | Table<any>[] | string | string[] };
 
export async function hashQuery(sql: string, params?: any[]) {
	const dataToHash = `${sql}-${JSON.stringify(params)}`;
	const encoder = new TextEncoder();
	const data = encoder.encode(dataToHash);
	const hashBuffer = await crypto.subtle.digest('SHA-256', data);
	const hashArray = [...new Uint8Array(hashBuffer)];
	const hashHex = hashArray.map((b) => b.toString(16).padStart(2, '0')).join('');
 
	return hashHex;
}

Copyexport type CacheConfig = {
	/**
	 * expire time, in seconds (a positive integer)
	 */
	ex?: number;
	/**
	 * expire time, in milliseconds (a positive integer).
	 */
	px?: number;
	/**
	 * Unix time at which the key will expire, in seconds (a positive integer).
	 */
	exat?: number;
	/**
	 * Unix time at which the key will expire, in milliseconds (a positive integer)
	 */
	pxat?: number;
	/**
	 * Retain the time to live associated with the key.
	 */
	keepTtl?: boolean;
	/**
	 * Set an expiration (TTL or time to live) on one or more fields of a given hash key.
	 * Used for HEXPIRE command
	 */
	hexOptions?: 'NX' | 'nx' | 'XX' | 'xx' | 'GT' | 'gt' | 'LT' | 'lt';
};
 
export type WithCacheConfig = { enable: boolean; config?: CacheConfig; tag?: string; autoInvalidate?: boolean };

Copyconst getByTagScript = `
local tagsMapKey = KEYS[1] -- tags map key
local tag        = ARGV[1] -- tag
 
local compositeTableName = redis.call('HGET', tagsMapKey, tag)
if not compositeTableName then
  return nil
end
 
local value = redis.call('HGET', compositeTableName, tag)
return value
`;
 
const onMutateScript = `
local tagsMapKey = KEYS[1] -- tags map key
local tables     = {}      -- initialize tables array
local tags       = ARGV    -- tags array
 
for i = 2, #KEYS do
  tables[#tables + 1] = KEYS[i] -- add all keys except the first one to tables
end
 
if #tags > 0 then
  for _, tag in ipairs(tags) do
    if tag ~= nil and tag ~= '' then
      local compositeTableName = redis.call('HGET', tagsMapKey, tag)
      if compositeTableName then
        redis.call('HDEL', compositeTableName, tag)
      end
    end
  end
  redis.call('HDEL', tagsMapKey, unpack(tags))
end
 
local keysToDelete = {}
 
if #tables > 0 then
  local compositeTableNames = redis.call('SUNION', unpack(tables))
  for _, compositeTableName in ipairs(compositeTableNames) do
    keysToDelete[#keysToDelete + 1] = compositeTableName
  end
  for _, table in ipairs(tables) do
    keysToDelete[#keysToDelete + 1] = table
  end
  redis.call('DEL', unpack(keysToDelete))
end
`;

Copyasync run(placeholderValues?: Record<string, unknown>): Promise<SqliteRemoteResult> {
	const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
	this.logger.logQuery(this.query.sql, params);
	return await this.queryWithCache(this.query.sql, params, async () => {
		return await (this.client as AsyncRemoteCallback)(this.query.sql, params, 'run');
	});
}

Copyexport type MutationOption = { tags?: string | string[]; tables?: Table<any> | Table<any>[] | string | string[] };

Copy	private options: TiDBServerlessSessionOptions = {},
) {
	super(dialect);
	this.client = tx ?? baseClient;
	this.logger = options.logger ?? new NoopLogger();
	this.cache = options.cache ?? new NoopCache();
}

Copyconstructor(
	private client: XataHttpClient,
	dialect: PgDialect,
	private schema: RelationalSchemaConfig<TSchema> | undefined,
	private options: XataHttpSessionOptions = {},
) {
	super(dialect);
	this.logger = options.logger ?? new NoopLogger();
	this.cache = options.cache ?? new NoopCache();
}

Copyconstructor(
	private client: GelClient,
	dialect: GelDialect,
	private schema: RelationalSchemaConfig<TSchema> | undefined,
	private options: GelSessionOptions = {},
) {
	super(dialect);
	this.logger = options.logger ?? new NoopLogger();
	this.cache = options.cache ?? new NoopCache();
}

Copy 
constructor(
	private client: PgliteClient | Transaction,
	dialect: PgDialect,
	private schema: RelationalSchemaConfig<TSchema> | undefined,
	private options: PgliteSessionOptions = {},
) {
	super(dialect);
	this.logger = options.logger ?? new NoopLogger();
	this.cache = options.cache ?? new NoopCache();
}

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

Copyconstructor(
	/** @internal */
	readonly client: AwsDataApiClient,
	dialect: PgDialect,
	private schema: RelationalSchemaConfig<TSchema> | undefined,
	private options: AwsDataApiSessionOptions,
	/** @internal */
	readonly transactionId: string | undefined,
) {
	super(dialect);
	this.rawQuery = {
		secretArn: options.secretArn,
		resourceArn: options.resourceArn,
		database: options.database,
	};
	this.cache = options.cache ?? new NoopCache();
}

Copyconstructor(
	public client: TSQL,
	dialect: PgDialect,
	private schema: RelationalSchemaConfig<TSchema> | undefined,
	/** @internal */
	readonly options: BunSQLSessionOptions = {},
) {
	super(dialect);
	this.logger = options.logger ?? new NoopLogger();
	this.cache = options.cache ?? new NoopCache();
}