feat: add type information to schema

Author: rakibansary

src/common/QueryRunner.ts

@@ -10,13 +10,13 @@ import {
 } from "@topcoder-framework/client-relational";
 import { TableColumn, TableColumns } from "./TableColumn";
 
-export type Schema = {
+export type Schema<T extends Record<string, any>> = {
   dbSchema: string;
   tableName: string;
   idColumn?: string;
   idSequence?: string;
   idTable?: string;
-  columns: TableColumns;
+  columns: TableColumns<T>;
 };
 
 interface ExecuteSqlQuery {
@@ -51,17 +51,17 @@ export interface InsertQuery<CreateInput> {
 }
 
 export interface UpdateQuery<UpdateInput> {
-  update(lookupCriteria: { [key: string]: unknown }, input: UpdateInput): ExecuteSqlQuery;
+  update(lookupCriteria: Record<string, unknown>, input: UpdateInput): ExecuteSqlQuery;
 }
 
 export interface DeleteQuery {
   delete(): ExecuteSqlQuery;
 }
 
 export class QueryRunner<
-  T,
-  CreateInput extends { [key: string]: unknown },
-  UpdateInput extends { [key: string]: unknown }
+  T extends Record<string, unknown>,
+  CreateInput extends Record<string, unknown>,
+  UpdateInput extends Record<string, unknown>
 > implements
     SelectQuery,
     JoinClause,
@@ -76,7 +76,7 @@ export class QueryRunner<
   #query: Query | null = null;
   #client: RelationalClient;
 
-  constructor(private schema: Schema) {
+  constructor(private schema: Schema<T>) {
     console.log("Connecting to GRPC server at", GRPC_RDB_SERVER_HOST, GRPC_RDB_SERVER_PORT, "...");
     this.#client = new RelationalClient(GRPC_RDB_SERVER_HOST!, parseInt(GRPC_RDB_SERVER_PORT!));
   }
@@ -167,7 +167,7 @@ export class QueryRunner<
             ...Object.entries(input)
               .filter(([_key, value]) => value !== undefined)
               .map(([key, value]) => ({
-                column: this.schema.columns[key].name,
+                column: this.schema.columns[key]?.name ?? key,
                 value: this.toValue(key, value),
               })),
           ],
@@ -206,7 +206,7 @@ export class QueryRunner<
           throw new Error("Unexpected result type");
         }
         return queryResponse.result.selectResult.rows.map((row) => {
-          return row as T;
+          return row as unknown as T;
         });
       case "insert":
         if (queryResponse.result?.$case != "insertResult") {

src/common/TableColumn.ts

@@ -5,6 +5,6 @@ export type TableColumn = {
   type: ColumnType;
 };
 
-export type TableColumns = {
-  [key: string]: TableColumn;
+export type TableColumns<T extends Record<string, unknown>> = {
+  [Property in keyof T]: TableColumn;
 };

src/domain/LegacyChallenge.ts

@@ -2,14 +2,14 @@ import { ColumnType, Operator, QueryRequest } from "@topcoder-framework/client-r
 import { Value } from "@topcoder-framework/lib-common";
 import { QueryRunner } from "../common/QueryRunner";
 import { CheckChallengeExistsResponse } from "../models/domain-layer/legacy/challenge";
-import { Project } from "../schema/project/Project";
+import { ProjectSchema } from "../schema/project/Project";
 
 class LegacyChallengeDomain {
   public async checkChallengeExists(
     legacyChallengeId: number
   ): Promise<CheckChallengeExistsResponse> {
-    const challenges = (await new QueryRunner(Project)
-      .select([Project.columns.projectId])
+    const challenges = (await new QueryRunner(ProjectSchema)
+      .select([ProjectSchema.columns.projectId])
       .where({
         key: "project_id",
         operator: Operator.OPERATOR_EQUAL,

src/domain/LegacyChallengePhase.ts

@@ -1,7 +1,7 @@
 import { QueryRunner } from "../common/QueryRunner";
 import { Value } from "@topcoder-framework/client-relational";
 import { CreatePhaseInput, PhaseTypeList } from "../models/domain-layer/legacy/challenge_phase";
-import { PhaseType } from "../schema/project/PhaseType";
+import { PhaseTypeSchema } from "../schema/project/PhaseType";
 import { ProjectPhaseSchema } from "../schema/project/ProjectPhase";
 import { CreateResult } from "@topcoder-framework/lib-common";
 
@@ -26,8 +26,8 @@ class LegacyChallengePhaseDomain {
   }
 
   public async getPhaseTypes(): Promise<PhaseTypeList> {
-    const projectPhases = (await new QueryRunner(PhaseType)
-      .select([PhaseType.columns.phaseTypeId, PhaseType.columns.name])
+    const projectPhases = (await new QueryRunner(PhaseTypeSchema)
+      .select([PhaseTypeSchema.columns.phaseTypeId, PhaseTypeSchema.columns.name])
       .limit(500)
       .offset(0)
       .exec()) as [

src/domain/Prize.ts

@@ -0,0 +1,85 @@
+import { CreateResult, ScanCriteria, Value } from "@topcoder-framework/lib-common";
+import { QueryRunner } from "../common/QueryRunner";
+import { CreatePrizeInput, Prize, PrizeList } from "../models/domain-layer/legacy/prize";
+import { PrizeSchema } from "../schema/project_payment/Prize";
+
+class PrizeDomain {
+  public async create(input: CreatePrizeInput): Promise<CreateResult> {
+    const createInput: Partial<Prize> = {
+      ...input,
+      createUser: 22838965, // tcwebservice | TODO: Get using grpc interceptor
+      modifyUser: 22838965, // tcwebservice | TODO: Get using grpc interceptor
+    };
+
+    const prizeId = (await new QueryRunner(PrizeSchema).insert(createInput).exec()) as number;
+    return {
+      kind: {
+        $case: "integerId",
+        integerId: prizeId,
+      },
+    };
+  }
+
+  public async scan(criteria: ScanCriteria): Promise<PrizeList> {
+    const prizes = (await new QueryRunner(PrizeSchema)
+      .select([
+        PrizeSchema.columns.prizeId,
+        PrizeSchema.columns.prizeTypeId,
+        PrizeSchema.columns.prizeAmount,
+        PrizeSchema.columns.place,
+        PrizeSchema.columns.numberOfSubmissions,
+        PrizeSchema.columns.projectId,
+        PrizeSchema.columns.createDate,
+        PrizeSchema.columns.createUser,
+        PrizeSchema.columns.modifyDate,
+        PrizeSchema.columns.modifyUser,
+      ])
+      .limit(10)
+      .offset(0)
+      .exec()) as [
+      {
+        values: {
+          prize_id: Value;
+          prize_type_id: number;
+          prize_amount: Value;
+          place: number;
+          number_of_submissions: number;
+          prize_description: string;
+          project_id: number;
+          create_date: number;
+          create_user: number;
+          modify_date: number;
+          modify_user: number;
+        };
+      }
+    ];
+
+    console.log("prizes", prizes);
+
+    const list: PrizeList = {
+      prizes: prizes.map(({ values }) => {
+        return {
+          prizeId:
+            values.prize_id.kind?.$case === "numberValue" ? values.prize_id.kind.numberValue : 12,
+          prizeTypeId: values.prize_type_id,
+          prizeAmount:
+            values.prize_amount.kind?.$case === "numberValue"
+              ? values.prize_amount.kind.numberValue
+              : 12,
+          place: values.place,
+          numberOfSubmissions: values.number_of_submissions,
+          prizeDescription: values.prize_description,
+          projectId: values.project_id,
+          createDate: values.create_date,
+          createUser: values.create_user,
+          modifyDate: values.modify_date,
+          modifyUser: values.modify_user,
+        };
+      }),
+    };
+
+    return list;
+  }
+}
+
+export default new PrizeDomain();

src/models/domain-layer/legacy/challenge.ts

@@ -25,6 +25,12 @@ export interface CheckChallengeExistsResponse {
   exists: boolean;
 }
 
+export interface CreateChallengeInput {
+  projectStatusId: number;
+  projectCategoryId: number;
+  tcDirectProjectId: number;
+}
+
 function createBaseLegacyChallenge(): LegacyChallenge {
   return {
     projectId: 0,
@@ -311,6 +317,77 @@ export const CheckChallengeExistsResponse = {
   },
 };
 
+function createBaseCreateChallengeInput(): CreateChallengeInput {
+  return { projectStatusId: 0, projectCategoryId: 0, tcDirectProjectId: 0 };
+}
+
+export const CreateChallengeInput = {
+  encode(message: CreateChallengeInput, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.projectStatusId !== 0) {
+      writer.uint32(8).int32(message.projectStatusId);
+    }
+    if (message.projectCategoryId !== 0) {
+      writer.uint32(16).int32(message.projectCategoryId);
+    }
+    if (message.tcDirectProjectId !== 0) {
+      writer.uint32(24).int64(message.tcDirectProjectId);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): CreateChallengeInput {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseCreateChallengeInput();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.projectStatusId = reader.int32();
+          break;
+        case 2:
+          message.projectCategoryId = reader.int32();
+          break;
+        case 3:
+          message.tcDirectProjectId = longToNumber(reader.int64() as Long);
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): CreateChallengeInput {
+    return {
+      projectStatusId: isSet(object.projectStatusId) ? Number(object.projectStatusId) : 0,
+      projectCategoryId: isSet(object.projectCategoryId) ? Number(object.projectCategoryId) : 0,
+      tcDirectProjectId: isSet(object.tcDirectProjectId) ? Number(object.tcDirectProjectId) : 0,
+    };
+  },
+
+  toJSON(message: CreateChallengeInput): unknown {
+    const obj: any = {};
+    message.projectStatusId !== undefined && (obj.projectStatusId = Math.round(message.projectStatusId));
+    message.projectCategoryId !== undefined && (obj.projectCategoryId = Math.round(message.projectCategoryId));
+    message.tcDirectProjectId !== undefined && (obj.tcDirectProjectId = Math.round(message.tcDirectProjectId));
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<CreateChallengeInput>, I>>(base?: I): CreateChallengeInput {
+    return CreateChallengeInput.fromPartial(base ?? {});
+  },
+
+  fromPartial<I extends Exact<DeepPartial<CreateChallengeInput>, I>>(object: I): CreateChallengeInput {
+    const message = createBaseCreateChallengeInput();
+    message.projectStatusId = object.projectStatusId ?? 0;
+    message.projectCategoryId = object.projectCategoryId ?? 0;
+    message.tcDirectProjectId = object.tcDirectProjectId ?? 0;
+    return message;
+  },
+};
+
 declare var self: any | undefined;
 declare var window: any | undefined;
 declare var global: any | undefined;