FilesExpand file tree

github

/

pgFunctionCache.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

62 lines (51 loc) · 2.07 KB

github

/

pgFunctionCache.ts

Copy path

Top

File metadata and controls

• Code
• Blame

62 lines (51 loc) · 2.07 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

import crypto from 'crypto';

import { Pool } from 'pg';

import { CacheScope, FunctionCacheService } from './functionCacheService';

// AI generated. Not yet tested --------------------------

// TypeORM doesn't work with TypeScript 5.0+ with the new decorators

const CREATE_FUNCTION_CACHE_TABLE_SQL = `

CREATE TABLE IF NOT EXISTS function_cache (

id SERIAL PRIMARY KEY,

hash VARCHAR(64) UNIQUE NOT NULL,

class_name TEXT NOT NULL,

method TEXT NOT NULL,

params JSON NOT NULL,

result JSON,

created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP

);

`;

export class PgFunctionCacheService implements FunctionCacheService {

private pool: Pool;

constructor(pool: Pool) {

this.pool = pool;

}

private static generateHash(className: string, method: string, params: any[]): string {

const hash = crypto.createHash('sha256');

hash.update(className);

hash.update(method);

hash.update(JSON.stringify(params));

return hash.digest('hex');

}

async getValue(scope: CacheScope, className: string, method: string, params: any[]): Promise<any> {

const hash = PgFunctionCacheService.generateHash(className, method, params);

const query = 'SELECT result FROM function_cache WHERE hash = $1';

const { rows } = await this.pool.query(query, [hash]);

return rows.length > 0 ? rows[0].result : undefined;

}

async setValue(scope: CacheScope, className: string, method: string, params: any[], value: any): Promise<void> {

const hash = PgFunctionCacheService.generateHash(className, method, params);

const query = `

INSERT INTO function_cache (hash, class_name, method, params, result)

VALUES ($1, $2, $3, $4, $5)

ON CONFLICT (hash) DO UPDATE SET result = EXCLUDED.result;

`;

await this.pool.query(query, [hash, className, method, JSON.stringify(params), JSON.stringify(value)]);

}

clearAgentCache(agentId: string): Promise<number> {

return Promise.resolve(0);

}

clearUserCache(userId: string): Promise<number> {

return Promise.resolve(0);

}

}

export const createFunctionCacheTableSql = CREATE_FUNCTION_CACHE_TABLE_SQL;