9031615006

Committed 10 May 2024 11:34AM UTC coverage: 31.899% (-0.003%) from 31.902%

Build # 9031615006

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #9255 from ForumMagnum/more-emoji-banner-tweaks

More emoji banner tweaks

Run Details

4765 of 39001 branches covered (12.22%)

Branch coverage included in aggregate %.

2 of 10 new or added lines in 2 files covered. (20.0%)

1 existing line in 1 file now uncovered.

27762 of 62967 relevant lines covered (44.09%)

177.99 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

11.63

/packages/lesswrong/server/repos/DatabaseMetadataRepo.ts

import AbstractRepo from "./AbstractRepo";
import { DatabaseMetadata } from "../../lib/collections/databaseMetadata/collection";
import type { TimeSeries } from "../../lib/collections/posts/karmaInflation";
import { randomId } from "../../lib/random";
import type { GivingSeasonHeart } from "../../components/review/ReviewVotingCanvas";
import type { BannerEmoji } from "../../components/ea-forum/EAEmojisHeader";

const BANNER_EMOJI_NAME = "banner-emojis-2024-05";

type RawBannerEmoji = {
  userId: string,
  t: string,
} & Pick<BannerEmoji, "emoji" | "link" | "description" | "x" | "y">;

export default class DatabaseMetadataRepo extends AbstractRepo<"DatabaseMetadata"> {
  constructor() {
    super(DatabaseMetadata);
  }

  private getByName(name: string): Promise<DbDatabaseMetadata | null> {
    // We use getRawDb here as this may be executed during server startup
    // before the collection is properly initialized
    return this.getRawDb().oneOrNone(`
      -- DatabaseMetadataRepo.getByName
      SELECT * from "DatabaseMetadata" WHERE "name" = $1
    `,
      [name],
      `DatabaseMetadata.${name}`,
    );
  }

  private electionNameToMetadataName(electionName: string): string {
    return `${electionName}Hearts`;
  }

  async getGivingSeasonHearts(electionName: string): Promise<GivingSeasonHeart[]> {
    const metadataName = this.electionNameToMetadataName(electionName);
    const result = await this.getRawDb().oneOrNone(`
      -- DatabaseMetadataRepo.getGivingSeasonHearts
      SELECT ARRAY_AGG(q."value" || JSONB_BUILD_OBJECT(
        'userId', u."_id",
        'displayName', u."displayName"
      )) "hearts"
      FROM (
        SELECT (JSONB_EACH("value")).*
        FROM "DatabaseMetadata"
        WHERE "name" = $1
      ) q
      JOIN "Users" u ON q."key" = u."_id"
    `, [metadataName]);
    return result?.hearts ?? [];
  }

  async addGivingSeasonHeart(
    electionName: string,
    userId: string,
    x: number,
    y: number,
    theta: number,
  ): Promise<GivingSeasonHeart[]> {
    const metadataName = this.electionNameToMetadataName(electionName);
    await this.none(`
      -- DatabaseMetadataRepo.addGivingSeasonHeart
      INSERT INTO "DatabaseMetadata" ("_id", "name", "value", "createdAt")
      VALUES ($1, $2, $3, CURRENT_TIMESTAMP)
      ON CONFLICT ("name") DO UPDATE SET "value" = "DatabaseMetadata"."value" || $3
    `, [
      randomId(),
      metadataName,
      {[userId]: {x, y, theta}},
    ]);
    return this.getGivingSeasonHearts(electionName);
  }

  async removeGivingSeasonHeart(
    electionName: string,
    userId: string,
  ): Promise<GivingSeasonHeart[]> {
    const metadataName = this.electionNameToMetadataName(electionName);
    await this.none(`
      -- DatabaseMetadataRepo.removeGivingSeasonHeart
      UPDATE "DatabaseMetadata"
      SET "value" = "value" - $1
      WHERE "name" = $2
    `, [userId, metadataName]);
    return this.getGivingSeasonHearts(electionName);
  }

  async getBannerEmojis(currentUserId?: string): Promise<BannerEmoji[]> {
    const result = await this.getRawDb().oneOrNone(`
      -- DatabaseMetadataRepo.getBannerEmojis
      SELECT ARRAY_AGG(q."value" || JSONB_BUILD_OBJECT(
        'displayName', 'a',
        'id', q."key",
        'userId', '',
        'isCurrentUser', q."value"->>'userId' = $2
      )) "emojis"
      FROM (
        SELECT (JSONB_EACH("value")).*
        FROM "DatabaseMetadata"
        WHERE "name" = $1
      ) q
    `, [BANNER_EMOJI_NAME, currentUserId ?? ""]);
    return result?.emojis ?? [];
  }

  async getBannerEmojiRaw(id: string): Promise<Partial<RawBannerEmoji> | null> {
    const result = await this.getRawDb().oneOrNone(`
      -- DatabaseMetadataRepo.getBannerEmojiRaw
      SELECT "value"->$2 "emoji"
      FROM "DatabaseMetadata"
      WHERE "name" = $1
    `, [BANNER_EMOJI_NAME, id]);
    return result?.emoji ?? null;
  }

  async addBannerEmoji(
    userId: string,
    emoji: string,
    link: string,
    description: string,
    x: number,
    y: number,
    theta: number,
  ): Promise<BannerEmoji[]> {
    const t = new Date().toISOString();
    await this.none(`
      -- DatabaseMetadataRepo.addBannerEmoji
      INSERT INTO "DatabaseMetadata" ("_id", "name", "value", "createdAt")
      VALUES ($1, $2, $3, CURRENT_TIMESTAMP)
      ON CONFLICT ("name") DO UPDATE SET "value" = "DatabaseMetadata"."value" || $3
    `, [
      randomId(),
      BANNER_EMOJI_NAME,
      {[randomId()]: {userId, emoji, link, description, x, y, theta, t}},
    ]);
    return this.getBannerEmojis();
  }

  async removeBannerEmoji(id: string): Promise<BannerEmoji[]> {
    await this.none(`
      -- DatabaseMetadataRepo.removeBannerEmoji
      UPDATE "DatabaseMetadata"
      SET "value" = "value" - $1
      WHERE "name" = $2
    `, [id, BANNER_EMOJI_NAME]);
    return this.getBannerEmojis();
  }

  getServerSettings(): Promise<DbDatabaseMetadata | null> {
    return this.getByName("serverSettings");
  }

  getPublicSettings(): Promise<DbDatabaseMetadata | null> {
    return this.getByName("publicSettings");
  }

  getDatabaseId(): Promise<DbDatabaseMetadata | null> {
    return this.getByName("databaseId");
  }

  upsertKarmaInflationSeries(karmaInflationSeries: TimeSeries): Promise<null> {
    return this.none(`
      INSERT INTO "DatabaseMetadata" (
        "_id",
        "name",
        "value",
        "schemaVersion",
        "createdAt"
      ) VALUES (
        $(_id), $(name), $(value), $(schemaVersion), $(createdAt)
      ) ON CONFLICT (
        "name"
      )
      DO UPDATE SET
        "value" = $(value)
      `, {
      _id: randomId(),
      name: "karmaInflationSeries",
      value: {...karmaInflationSeries},
      schemaVersion: 1,
      createdAt: new Date(),
    });
  }
}

1	import AbstractRepo from "./AbstractRepo";	1,716✔
2	import { DatabaseMetadata } from "../../lib/collections/databaseMetadata/collection";	19✔
3	import type { TimeSeries } from "../../lib/collections/posts/karmaInflation";
4	import { randomId } from "../../lib/random";	19✔
5	import type { GivingSeasonHeart } from "../../components/review/ReviewVotingCanvas";
6	import type { BannerEmoji } from "../../components/ea-forum/EAEmojisHeader";
7
8	const BANNER_EMOJI_NAME = "banner-emojis-2024-05";	19✔
9
10	type RawBannerEmoji = {
11	userId: string,
12	t: string,
13	} & Pick<BannerEmoji, "emoji" \| "link" \| "description" \| "x" \| "y">;
14
15	export default class DatabaseMetadataRepo extends AbstractRepo<"DatabaseMetadata"> {
16	constructor() {
17	super(DatabaseMetadata);	1,659✔
18	}
19
20	private getByName(name: string): Promise<DbDatabaseMetadata \| null> {
21	// We use getRawDb here as this may be executed during server startup
22	// before the collection is properly initialized
23	return this.getRawDb().oneOrNone(`	×
24	-- DatabaseMetadataRepo.getByName
25	SELECT * from "DatabaseMetadata" WHERE "name" = $1
26	`,
27	[name],
28	`DatabaseMetadata.${name}`,
29	);
30	}
31
32	private electionNameToMetadataName(electionName: string): string {
33	return `${electionName}Hearts`;	×
34	}
35
36	async getGivingSeasonHearts(electionName: string): Promise<GivingSeasonHeart[]> {
37	const metadataName = this.electionNameToMetadataName(electionName);	×
38	const result = await this.getRawDb().oneOrNone(`	×
39	-- DatabaseMetadataRepo.getGivingSeasonHearts
40	SELECT ARRAY_AGG(q."value" \|\| JSONB_BUILD_OBJECT(
41	'userId', u."_id",
42	'displayName', u."displayName"
43	)) "hearts"
44	FROM (
45	SELECT (JSONB_EACH("value")).*
46	FROM "DatabaseMetadata"
47	WHERE "name" = $1
48	) q
49	JOIN "Users" u ON q."key" = u."_id"
50	`, [metadataName]);
51	return result?.hearts ?? [];	×
52	}
53
54	async addGivingSeasonHeart(
55	electionName: string,
56	userId: string,
57	x: number,
58	y: number,
59	theta: number,
60	): Promise<GivingSeasonHeart[]> {
61	const metadataName = this.electionNameToMetadataName(electionName);	×
62	await this.none(`	×
63	-- DatabaseMetadataRepo.addGivingSeasonHeart
64	INSERT INTO "DatabaseMetadata" ("_id", "name", "value", "createdAt")
65	VALUES ($1, $2, $3, CURRENT_TIMESTAMP)
66	ON CONFLICT ("name") DO UPDATE SET "value" = "DatabaseMetadata"."value" \|\| $3
67	`, [
68	randomId(),
69	metadataName,
70	{[userId]: {x, y, theta}},
71	]);
72	return this.getGivingSeasonHearts(electionName);	×
73	}
74
75	async removeGivingSeasonHeart(
76	electionName: string,
77	userId: string,
78	): Promise<GivingSeasonHeart[]> {
79	const metadataName = this.electionNameToMetadataName(electionName);	×
80	await this.none(`	×
81	-- DatabaseMetadataRepo.removeGivingSeasonHeart
82	UPDATE "DatabaseMetadata"
83	SET "value" = "value" - $1
84	WHERE "name" = $2
85	`, [userId, metadataName]);
86	return this.getGivingSeasonHearts(electionName);	×
87	}
88
89	async getBannerEmojis(currentUserId?: string): Promise<BannerEmoji[]> {
90	const result = await this.getRawDb().oneOrNone(`	×
91	-- DatabaseMetadataRepo.getBannerEmojis
92	SELECT ARRAY_AGG(q."value" \|\| JSONB_BUILD_OBJECT(
93	'displayName', 'a',
94	'id', q."key",
95	'userId', '',
96	'isCurrentUser', q."value"->>'userId' = $2
97	)) "emojis"
98	FROM (
99	SELECT (JSONB_EACH("value")).*
100	FROM "DatabaseMetadata"
101	WHERE "name" = $1
102	) q
103	`, [BANNER_EMOJI_NAME, currentUserId ?? ""]);	×
UNCOV 104	return result?.emojis ?? [];	×
105	}
106
107	async getBannerEmojiRaw(id: string): Promise<Partial<RawBannerEmoji> \| null> {
108	const result = await this.getRawDb().oneOrNone(`	×
109	-- DatabaseMetadataRepo.getBannerEmojiRaw
110	SELECT "value"->$2 "emoji"
111	FROM "DatabaseMetadata"
112	WHERE "name" = $1
113	`, [BANNER_EMOJI_NAME, id]);
114	return result?.emoji ?? null;	×
115	}
116
117	async addBannerEmoji(
118	userId: string,
119	emoji: string,
120	link: string,
121	description: string,
122	x: number,
123	y: number,
124	theta: number,
125	): Promise<BannerEmoji[]> {
126	const t = new Date().toISOString();	×
127	await this.none(`	×
128	-- DatabaseMetadataRepo.addBannerEmoji
129	INSERT INTO "DatabaseMetadata" ("_id", "name", "value", "createdAt")
130	VALUES ($1, $2, $3, CURRENT_TIMESTAMP)
131	ON CONFLICT ("name") DO UPDATE SET "value" = "DatabaseMetadata"."value" \|\| $3
132	`, [
133	randomId(),
134	BANNER_EMOJI_NAME,
135	{[randomId()]: {userId, emoji, link, description, x, y, theta, t}},
136	]);
137	return this.getBannerEmojis();	×
138	}
139
140	async removeBannerEmoji(id: string): Promise<BannerEmoji[]> {
141	await this.none(`	×
142	-- DatabaseMetadataRepo.removeBannerEmoji
143	UPDATE "DatabaseMetadata"
144	SET "value" = "value" - $1
145	WHERE "name" = $2
146	`, [id, BANNER_EMOJI_NAME]);
147	return this.getBannerEmojis();	×
148	}
149
150	getServerSettings(): Promise<DbDatabaseMetadata \| null> {
151	return this.getByName("serverSettings");	×
152	}
153
154	getPublicSettings(): Promise<DbDatabaseMetadata \| null> {
155	return this.getByName("publicSettings");	×
156	}
157
158	getDatabaseId(): Promise<DbDatabaseMetadata \| null> {
159	return this.getByName("databaseId");	×
160	}
161
162	upsertKarmaInflationSeries(karmaInflationSeries: TimeSeries): Promise<null> {
163	return this.none(`	×
164	INSERT INTO "DatabaseMetadata" (
165	"_id",
166	"name",
167	"value",
168	"schemaVersion",
169	"createdAt"
170	) VALUES (
171	$(_id), $(name), $(value), $(schemaVersion), $(createdAt)
172	) ON CONFLICT (
173	"name"
174	)
175	DO UPDATE SET
176	"value" = $(value)
177	`, {
178	_id: randomId(),
179	name: "karmaInflationSeries",
180	value: {...karmaInflationSeries},
181	schemaVersion: 1,
182	createdAt: new Date(),
183	});
184	}
185	}

ForumMagnum / ForumMagnum / 9031615006

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous