feat(idea/meta-storage): support sails idl

idea/common/src/interfaces/rpc-request/meta-storage.ts

@@ -13,3 +13,8 @@ export interface GetMetaParams {
   hash: string;
   hex: HexString;
 }
+
+export interface AddSailsIdlParams {
+  codeId: string;
+  data: string;
+}

idea/common/src/jsonrpc-errors.ts

@@ -109,6 +109,11 @@ export const JSONRPC_ERRORS = {
     code: -32400,
     message: 'Address is not supported',
   },
+  SailsIdlNotFound: {
+    name: 'SailsIdlNotFound',
+    code: -32404,
+    message: 'Sails IDL not found',
+  },
 };
 
 export function isExistError(name: string) {

idea/meta-storage/src/database/data-source.ts

@@ -1,6 +1,6 @@
 import { DataSource } from 'typeorm';
 
-import { Meta } from './entities';
+import { Code, Meta, SailsIdl } from './entities';
 import config from '../config';
 
 export const AppDataSource = new DataSource({
@@ -10,7 +10,7 @@ export const AppDataSource = new DataSource({
   username: config.db.user,
   password: config.db.password,
   database: config.db.name,
-  entities: [Meta],
+  entities: [Meta, SailsIdl, Code],
   synchronize: true,
   logging: ['error', 'schema'],
 });

idea/meta-storage/src/database/entities/code.entity.ts

@@ -0,0 +1,15 @@
+import { Entity, ManyToOne, PrimaryColumn } from 'typeorm';
+import { SailsIdl } from './sails.entity';
+
+@Entity()
+export class Code {
+  constructor(props: Partial<Code>) {
+    Object.assign(this, props);
+  }
+
+  @PrimaryColumn()
+    id: string;
+
+  @ManyToOne(() => SailsIdl, (sails) => sails.codes)
+    sails: SailsIdl;
+}

idea/meta-storage/src/database/entities/index.ts

@@ -1 +1,3 @@
 export { Meta } from './meta.entity';
+export { SailsIdl } from './sails.entity';
+export { Code } from './code.entity';

idea/meta-storage/src/database/entities/sails.entity.ts

@@ -0,0 +1,18 @@
+import { Column, Entity, OneToMany, PrimaryColumn } from 'typeorm';
+import { Code } from './code.entity';
+
+@Entity()
+export class SailsIdl {
+  constructor(props: Partial<SailsIdl>) {
+    Object.assign(this, props);
+  }
+
+  @PrimaryColumn()
+    id: string;
+
+  @Column()
+    data: string;
+
+  @OneToMany(() => Code, (code) => code.id)
+    codes: Code[];
+}

idea/meta-storage/src/service.ts

@@ -1,16 +1,24 @@
-import { Repository } from 'typeorm';
 import { AddMetaDetailsParams, AddMetahashParams, GetMetaParams, logger } from '@gear-js/common';
+import { ProgramMetadata, MetadataVersion, HumanTypesRepr } from '@gear-js/api';
+import { Repository } from 'typeorm';
+import * as crypto from 'crypto';
 
-import { Meta, AppDataSource } from './database';
-import { InvalidParamsError, MetaNotFoundError } from './util/errors';
+import { Meta, AppDataSource, SailsIdl } from './database';
+import { InvalidParamsError, MetaNotFoundError, SailsIdlNotFoundError } from './util/errors';
 import { validateMetaHex } from './util/validate';
-import { ProgramMetadata, MetadataVersion, HumanTypesRepr } from '@gear-js/api';
+import { Code } from './database/entities/code.entity';
+
+const getHash = (data: string) => crypto.createHash('sha256').update(data).digest('hex');
 
 export class MetaService {
   private metaRepo: Repository<Meta>;
+  private sailsRepo: Repository<SailsIdl>;
+  private codeRepo: Repository<Code>;
 
   constructor() {
     this.metaRepo = AppDataSource.getRepository(Meta);
+    this.sailsRepo = AppDataSource.getRepository(SailsIdl);
+    this.codeRepo = AppDataSource.getRepository(Code);
   }
 
   async addMeta({ metahash }: AddMetahashParams): Promise<string[]> {
@@ -82,4 +90,33 @@ export class MetaService {
     const meta = await this.metaRepo.find({ where: { hasState: true }, select: { hash: true } });
     return meta.map((m) => m.hash);
   }
+
+  async addIdl({ codeId, data }) {
+    const hash = getHash(data);
+
+    let sails = await this.sailsRepo.findOne({ where: { id: hash } });
+
+    if (!sails) {
+      const code = await this.codeRepo.findOne({ where: { id: codeId } });
+      if (code) {
+        throw new InvalidParamsError('Code already has IDL');
+      }
+      sails = new SailsIdl({ id: hash, data });
+    }
+
+    const code = new Code({ id: codeId, sails });
+
+    await this.sailsRepo.save(sails);
+    await this.codeRepo.save(code);
+  }
+
+  async getIdl({ codeId }) {
+    const code = await this.codeRepo.findOne({ where: { id: codeId }, relations: { sails: true } });
+
+    if (!code) {
+      throw new SailsIdlNotFoundError();
+    }
+
+    return code.sails.data;
+  }
 }

idea/meta-storage/src/util/errors.ts

@@ -11,3 +11,7 @@ export class InvalidMetadataError extends Error {
 export class InvalidParamsError extends Error {
   name = JSONRPC_ERRORS.InvalidParams.name;
 }
+
+export class SailsIdlNotFoundError extends Error {
+  name = JSONRPC_ERRORS.SailsIdlNotFound.name;
+}