9549930473

Committed 17 Jun 2024 02:55PM UTC coverage: 12.845%. Remained the same

Build # 9549930473

Build Type

Pull #8071

github

Committed by

web-flow

Commit Message

Merge fbab115ef into ea44a68a7

Pull Request Pull Request #8071: Unifying members count (Part 1/2)

Run Details

3843 of 35461 branches covered (10.84%)

Branch coverage included in aggregate %.

9 of 29 new or added lines in 6 files covered. (31.03%)

1 existing line in 1 file now uncovered.

5195 of 34900 relevant lines covered (14.89%)

4.8 hits per line

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

33.33

/libs/model/src/models/address.ts

import { Role, WalletId, WalletSsoSource } from '@hicommonwealth/shared';
import Sequelize from 'sequelize';
import type { CommunityAttributes, CommunityInstance } from './community';
import { MembershipAttributes } from './membership';
import type { ProfileAttributes, ProfileInstance } from './profile';
import type { SsoTokenAttributes, SsoTokenInstance } from './sso_token';
import type { ModelInstance } from './types';
import type { UserAttributes, UserInstance } from './user';

export type AddressAttributes = {
  address: string;
  community_id: string;
  verification_token: string;
  role: Role;
  is_user_default: boolean;
  id?: number;
  verification_token_expires?: Date;
  verified?: Date;
  keytype?: string;
  block_info?: string;
  last_active?: Date;
  created_at?: Date;
  updated_at?: Date;
  user_id?: number;
  is_councillor?: boolean;
  is_validator?: boolean;
  ghost_address?: boolean;
  // Cosmos self-custodial wallets only.
  // hex is derived from bech32 address using bech32ToHex function in
  // packages/commonwealth/shared/utils.ts
  hex?: string;
  profile_id?: number;
  wallet_id?: WalletId;
  wallet_sso_source?: WalletSsoSource;
  // associations
  Community?: CommunityAttributes;
  Profile?: ProfileAttributes;
  User?: UserAttributes;
  SsoToken?: SsoTokenAttributes;
  Memberships?: MembershipAttributes[];
};

export type AddressInstance = ModelInstance<AddressAttributes> & {
  getCommunity: Sequelize.BelongsToGetAssociationMixin<CommunityInstance>;
  getUser: Sequelize.BelongsToGetAssociationMixin<UserInstance>;
  getProfile: Sequelize.BelongsToGetAssociationMixin<ProfileInstance>;
  getSsoToken: Sequelize.HasOneGetAssociationMixin<SsoTokenInstance>;
};

export default (
  sequelize: Sequelize.Sequelize,
): Sequelize.ModelStatic<AddressInstance> =>
  sequelize.define<AddressInstance>(
    'Address',
    {
      id: { type: Sequelize.INTEGER, autoIncrement: true, primaryKey: true },
      address: { type: Sequelize.STRING, allowNull: false },
      community_id: { type: Sequelize.STRING, allowNull: false },
      role: {
        type: Sequelize.ENUM('member', 'moderator', 'admin'),
        defaultValue: 'member',
        allowNull: false,
      },
      is_user_default: {
        type: Sequelize.BOOLEAN,
        defaultValue: false,
        allowNull: false,
      },
      verification_token: { type: Sequelize.STRING, allowNull: false },
      verification_token_expires: { type: Sequelize.DATE, allowNull: true },
      verified: { type: Sequelize.DATE, allowNull: true },
      keytype: { type: Sequelize.STRING, allowNull: true },
      last_active: { type: Sequelize.DATE, allowNull: true },
      created_at: { type: Sequelize.DATE, allowNull: false },
      updated_at: { type: Sequelize.DATE, allowNull: false },
      user_id: { type: Sequelize.INTEGER, allowNull: true },
      is_councillor: {
        type: Sequelize.BOOLEAN,
        allowNull: false,
        defaultValue: false,
      },
      is_validator: {
        type: Sequelize.BOOLEAN,
        allowNull: false,
        defaultValue: false,
      },
      ghost_address: {
        type: Sequelize.BOOLEAN,
        allowNull: false,
        defaultValue: false,
      },
      profile_id: { type: Sequelize.INTEGER, allowNull: true },
      wallet_id: { type: Sequelize.STRING, allowNull: true },
      wallet_sso_source: { type: Sequelize.STRING, allowNull: true },
      block_info: { type: Sequelize.STRING, allowNull: true },
      hex: {
        type: Sequelize.STRING(64),
        allowNull: true,
        validate: {
          isRequiredForCosmos() {
            if (
              [
                WalletId.Keplr,
                WalletId.Leap,
                WalletId.KeplrEthereum,
                WalletId.TerraStation,
                WalletId.CosmosEvmMetamask,
              ].includes(this.wallet_id as WalletId)
            ) {
              if (!this.hex) {
                throw new Error('hex is required for cosmos addresses');
              }
            }
          },
        },
      },
    },
    {
      timestamps: true,
      createdAt: 'created_at',
      updatedAt: 'updated_at',
      underscored: true,
      tableName: 'Addresses',
      indexes: [
        { fields: ['address', 'community_id'], unique: true },
        { fields: ['user_id'] },
      ],
      defaultScope: {
        attributes: {
          exclude: [
            'verification_token',
            'verification_token_expires',
            'block_info',
            'created_at',
            'updated_at',
          ],
        },
      },
      scopes: {
        withPrivateData: {},
      },
      hooks: {
        afterCreate: async (
          address: AddressInstance,
          options: Sequelize.CreateOptions<AddressAttributes>,
        ) => {
          await sequelize.models.Community.increment('address_count', {
            by: 1,
            where: { id: address.community_id },
            transaction: options.transaction,
          });
        },
        afterDestroy: async (
          address: AddressInstance,
          options: Sequelize.InstanceDestroyOptions,
        ) => {
          await sequelize.models.Community.decrement('address_count', {
            by: 1,
            where: { id: address.community_id },
            transaction: options.transaction,
          });

          await sequelize.query(
            `
            UPDATE "Communities" as c
            SET profile_count = profile_count - 1,
            WHERE c.id = :community_id
            AND NOT EXISTS (
                SELECT 1
                FROM "Addresses" as a
                WHERE a.community_id = c.id AND a.user_id = :user_id
            );
            `,
            {
              replacements: {
                community_id: address.community_id,
                user_id: address.user_id,
              },
              transaction: options.transaction,
            },
          );
        },
      },
    },
  );

1	import { Role, WalletId, WalletSsoSource } from '@hicommonwealth/shared';
2	import Sequelize from 'sequelize';
3	import type { CommunityAttributes, CommunityInstance } from './community';
4	import { MembershipAttributes } from './membership';
5	import type { ProfileAttributes, ProfileInstance } from './profile';
6	import type { SsoTokenAttributes, SsoTokenInstance } from './sso_token';
7	import type { ModelInstance } from './types';
8	import type { UserAttributes, UserInstance } from './user';
9
10	export type AddressAttributes = {
11	address: string;
12	community_id: string;
13	verification_token: string;
14	role: Role;
15	is_user_default: boolean;
16	id?: number;
17	verification_token_expires?: Date;
18	verified?: Date;
19	keytype?: string;
20	block_info?: string;
21	last_active?: Date;
22	created_at?: Date;
23	updated_at?: Date;
24	user_id?: number;
25	is_councillor?: boolean;
26	is_validator?: boolean;
27	ghost_address?: boolean;
28	// Cosmos self-custodial wallets only.
29	// hex is derived from bech32 address using bech32ToHex function in
30	// packages/commonwealth/shared/utils.ts
31	hex?: string;
32	profile_id?: number;
33	wallet_id?: WalletId;
34	wallet_sso_source?: WalletSsoSource;
35	// associations
36	Community?: CommunityAttributes;
37	Profile?: ProfileAttributes;
38	User?: UserAttributes;
39	SsoToken?: SsoTokenAttributes;
40	Memberships?: MembershipAttributes[];
41	};
42
43	export type AddressInstance = ModelInstance<AddressAttributes> & {
44	getCommunity: Sequelize.BelongsToGetAssociationMixin<CommunityInstance>;
45	getUser: Sequelize.BelongsToGetAssociationMixin<UserInstance>;
46	getProfile: Sequelize.BelongsToGetAssociationMixin<ProfileInstance>;
47	getSsoToken: Sequelize.HasOneGetAssociationMixin<SsoTokenInstance>;
48	};
49
50	export default (
51	sequelize: Sequelize.Sequelize,
52	): Sequelize.ModelStatic<AddressInstance> =>
53	sequelize.define<AddressInstance>(	32✔
54	'Address',
55	{
56	id: { type: Sequelize.INTEGER, autoIncrement: true, primaryKey: true },
57	address: { type: Sequelize.STRING, allowNull: false },
58	community_id: { type: Sequelize.STRING, allowNull: false },
59	role: {
60	type: Sequelize.ENUM('member', 'moderator', 'admin'),
61	defaultValue: 'member',
62	allowNull: false,
63	},
64	is_user_default: {
65	type: Sequelize.BOOLEAN,
66	defaultValue: false,
67	allowNull: false,
68	},
69	verification_token: { type: Sequelize.STRING, allowNull: false },
70	verification_token_expires: { type: Sequelize.DATE, allowNull: true },
71	verified: { type: Sequelize.DATE, allowNull: true },
72	keytype: { type: Sequelize.STRING, allowNull: true },
73	last_active: { type: Sequelize.DATE, allowNull: true },
74	created_at: { type: Sequelize.DATE, allowNull: false },
75	updated_at: { type: Sequelize.DATE, allowNull: false },
76	user_id: { type: Sequelize.INTEGER, allowNull: true },
77	is_councillor: {
78	type: Sequelize.BOOLEAN,
79	allowNull: false,
80	defaultValue: false,
81	},
82	is_validator: {
83	type: Sequelize.BOOLEAN,
84	allowNull: false,
85	defaultValue: false,
86	},
87	ghost_address: {
88	type: Sequelize.BOOLEAN,
89	allowNull: false,
90	defaultValue: false,
91	},
92	profile_id: { type: Sequelize.INTEGER, allowNull: true },
93	wallet_id: { type: Sequelize.STRING, allowNull: true },
94	wallet_sso_source: { type: Sequelize.STRING, allowNull: true },
95	block_info: { type: Sequelize.STRING, allowNull: true },
96	hex: {
97	type: Sequelize.STRING(64),
98	allowNull: true,
99	validate: {
100	isRequiredForCosmos() {
101	if (	19!
102	[
103	WalletId.Keplr,
104	WalletId.Leap,
105	WalletId.KeplrEthereum,
106	WalletId.TerraStation,
107	WalletId.CosmosEvmMetamask,
108	].includes(this.wallet_id as WalletId)
109	) {
110	if (!this.hex) {	×
111	throw new Error('hex is required for cosmos addresses');	×
112	}
113	}
114	},
115	},
116	},
117	},
118	{
119	timestamps: true,
120	createdAt: 'created_at',
121	updatedAt: 'updated_at',
122	underscored: true,
123	tableName: 'Addresses',
124	indexes: [
125	{ fields: ['address', 'community_id'], unique: true },
126	{ fields: ['user_id'] },
127	],
128	defaultScope: {
129	attributes: {
130	exclude: [
131	'verification_token',
132	'verification_token_expires',
133	'block_info',
134	'created_at',
135	'updated_at',
136	],
137	},
138	},
139	scopes: {
140	withPrivateData: {},
141	},
142	hooks: {
143	afterCreate: async (
144	address: AddressInstance,
145	options: Sequelize.CreateOptions<AddressAttributes>,
146	) => {
147	await sequelize.models.Community.increment('address_count', {	19✔
148	by: 1,
149	where: { id: address.community_id },
150	transaction: options.transaction,
151	});
152	},
153	afterDestroy: async (
154	address: AddressInstance,
155	options: Sequelize.InstanceDestroyOptions,
156	) => {
157	await sequelize.models.Community.decrement('address_count', {	×
158	by: 1,
159	where: { id: address.community_id },
160	transaction: options.transaction,
161	});
162
NEW 163	await sequelize.query(	×
164	`
165	UPDATE "Communities" as c
166	SET profile_count = profile_count - 1,
167	WHERE c.id = :community_id
168	AND NOT EXISTS (
169	SELECT 1
170	FROM "Addresses" as a
171	WHERE a.community_id = c.id AND a.user_id = :user_id
172	);
173	`,
174	{
175	replacements: {
176	community_id: address.community_id,
177	user_id: address.user_id,
178	},
179	transaction: options.transaction,
180	},
181	);
182	},
183	},
184	},
185	);

hicommonwealth / commonwealth / 9549930473

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