@abtnode/core 1.16.16 → 1.16.17-beta-8cacb9b3

package/lib/blocklet/manager/disk.js

@@ -167,6 +167,17 @@ const { sessionConfigSchema } = require('../../validators/util');
 
 const request = require('../../util/request');
 const ConfigSynchronizer = require('./config-synchronizer');
+const {
+  createProject,
+  getProject,
+  getProjects,
+  updateProject,
+  deleteProject,
+  createRelease,
+  getReleases,
+  getRelease,
+  deleteRelease,
+} = require('../project');
 
 const { formatEnvironments, getBlockletMeta, validateOwner, isCLI } = util;
 
@@ -1521,8 +1532,14 @@ class DiskBlockletManager extends BaseBlockletManager {
     return getBlocklet({ ...opts, states, dataDirs: this.dataDirs, did, ensureIntegrity: true });
   }
 
-  getBlocklet(did, opts = {}) {
-    return getBlocklet({ ...opts, states, dataDirs: this.dataDirs, did, ensureIntegrity: false });
+  async getBlocklet(did, opts = {}) {
+    if (opts.useCache && this.cachedBlocklets.has(did)) {
+      return this.cachedBlocklets.get(did);
+    }
+
+    const blocklet = await getBlocklet({ ...opts, states, dataDirs: this.dataDirs, did, ensureIntegrity: false });
+    this.cachedBlocklets.set(did, blocklet);
+    return blocklet;
   }
 
   hasBlocklet({ did }) {
@@ -1869,10 +1886,55 @@ class DiskBlockletManager extends BaseBlockletManager {
     return this.configSynchronizer.syncAppConfig(did, { serverVersion });
   }
 
+  createProject({ did, ...params } = {}) {
+    return createProject({ did, ...params, manager: this });
+  }
+
+  getProjects({ did } = {}) {
+    return getProjects({ did, manager: this });
+  }
+
+  getProject({ did, projectId } = {}) {
+    return getProject({ did, projectId, manager: this });
+  }
+
+  updateProject({ did, projectId, ...params } = {}) {
+    return updateProject({ did, projectId, ...params, manager: this });
+  }
+
+  deleteProject({ did, projectId } = {}) {
+    return deleteProject({ did, projectId, manager: this });
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  createRelease({ did, projectId, ...params } = {}, context) {
+    return createRelease({ did, projectId, ...params, manager: this });
+  }
+
+  getReleases({ did, projectId } = {}) {
+    return getReleases({ did, projectId, manager: this });
+  }
+
+  getRelease({ did, projectId, releaseId } = {}) {
+    return getRelease({ did, projectId, releaseId, manager: this });
+  }
+
+  deleteRelease({ did, projectId, releaseId } = {}) {
+    return deleteRelease({ did, projectId, releaseId, manager: this });
+  }
+
   // ============================================================================================
   // Private API that are used by self of helper function
   // ============================================================================================
 
+  _getProjectState(did) {
+    return this.teamManager.getProjectState(did);
+  }
+
+  _getSessionState(did) {
+    return this.teamManager.getSessionState(did);
+  }
+
   /**
    *
    *
@@ -2747,17 +2809,36 @@ class DiskBlockletManager extends BaseBlockletManager {
       }
       logger.info('done migration on upgrading', { did, componentDids });
 
-      if (oldBlocklet.status === BlockletStatus.running) {
-        try {
-          await this.start({ did, componentDids }, context);
-          logger.info('started blocklet for upgrading', { did, version, componentDids });
-        } catch (error) {
-          logger.error('failed to start blocklet for upgrading', { did, version, componentDids, error });
-        }
+      if (action === INSTALL_ACTIONS.INSTALL_COMPONENT) {
+        await states.blocklet.setBlockletStatus(did, BlockletStatus.installed, { componentDids });
       } else {
-        const status =
-          oldBlocklet.status === BlockletStatus.installed ? BlockletStatus.installed : BlockletStatus.stopped;
-        await states.blocklet.setBlockletStatus(did, status, { componentDids });
+        const runningDids = [];
+        const stoppedDids = [];
+        const installedDids = [];
+        for (const componentDid of componentDids) {
+          const old = oldBlocklet.children.find((x) => x.meta.did === componentDid);
+          if (old?.status === BlockletStatus.running) {
+            runningDids.push(componentDid);
+          } else if (old?.status === BlockletStatus.installed) {
+            installedDids.push(componentDid);
+          } else {
+            stoppedDids.push(componentDid);
+          }
+        }
+        if (runningDids.length) {
+          try {
+            await this.start({ did, componentDids: runningDids }, context);
+            logger.info('started blocklet for upgrading', { did, version, runningDids });
+          } catch (error) {
+            logger.error('failed to start blocklet for upgrading', { did, version, runningDids, error });
+          }
+        }
+        if (stoppedDids.length) {
+          await states.blocklet.setBlockletStatus(did, BlockletStatus.stopped, { componentDids: stoppedDids });
+        }
+        if (installedDids.length) {
+          await states.blocklet.setBlockletStatus(did, BlockletStatus.installed, { componentDids: installedDids });
+        }
       }
 
       blocklet = await this.getBlocklet(did, context);

package/lib/blocklet/manager/helper/install-component-from-url.js

@@ -2,7 +2,7 @@ const { sign } = require('@arcblock/jwt');
 
 const logger = require('@abtnode/logger')('@abtnode/core:install-component-url');
 
-const { isFreeBlocklet, isComponentBlocklet } = require('@blocklet/meta/lib/util');
+const { isFreeBlocklet } = require('@blocklet/meta/lib/util');
 const { titleSchema } = require('@blocklet/meta/lib/schema');
 const hasReservedKey = require('@blocklet/meta/lib/has-reserved-key');
 
@@ -40,7 +40,7 @@ const installComponentFromUrl = async ({
 
   checkStructVersion(blocklet);
 
-  const { inStore } = await StoreUtil.parseSourceUrl(url);
+  const { inStore, registryUrl } = await StoreUtil.parseSourceUrl(url);
 
   const meta = await getBlockletMetaFromUrl(url);
 
@@ -66,14 +66,6 @@ const installComponentFromUrl = async ({
     };
   }
 
-  if (!isComponentBlocklet(meta)) {
-    throw new Error(
-      `The blocklet cannot be a component : ${
-        meta.title || meta.name
-      }. The reason may be that the developer set capabilities.component to false in blocklet.yml`
-    );
-  }
-
   if (title) {
     meta.title = await titleSchema.validateAsync(title);
   }
@@ -84,7 +76,14 @@ const installComponentFromUrl = async ({
   const newChild = {
     meta: newChildMeta,
     mountPoint: mountPoint || formatName(newChildMeta.name),
-    bundleSource: { url },
+    bundleSource: inStore
+      ? {
+          store: registryUrl,
+          name: meta.bundleName || meta.name,
+          // FIXME @linchen version should be specified
+          version: 'latest',
+        }
+      : { url },
   };
 
   const { dynamicComponents } = await parseComponents(newChild);
@@ -110,7 +109,7 @@ const installComponentFromUrl = async ({
   checkVersionCompatibility(blocklet.children);
 
   const oldBlocklet = await manager._getBlockletForInstallation(rootDid);
-  const action = index > 0 ? INSTALL_ACTIONS.UPGRADE_COMPONENT : INSTALL_ACTIONS.INSTALL_COMPONENT;
+  const action = index >= 0 ? INSTALL_ACTIONS.UPGRADE_COMPONENT : INSTALL_ACTIONS.INSTALL_COMPONENT;
   try {
     // add component to db
     await states.blocklet.addChildren(rootDid, newChildren);

package/lib/blocklet/project/index.js

@@ -0,0 +1,325 @@
+const path = require('path');
+const fs = require('fs-extra');
+const createArchive = require('archiver');
+const { slugify } = require('transliteration');
+const { BLOCKLET_META_FILE, PROJECT } = require('@blocklet/constant');
+const { update: updateMetaFile } = require('@blocklet/meta/lib/file');
+const { createRelease: createBlockletRelease } = require('@abtnode/util/lib/create-blocklet-release');
+const { titleSchema } = require('@blocklet/meta/lib/schema');
+const { validateNewDid } = require('@blocklet/meta/lib/name');
+const urlPathFriendly = require('@blocklet/meta/lib/url-path-friendly').default;
+
+const logger = require('@abtnode/logger')('create-resource-blocklet');
+
+const { createReleaseSchema } = require('../../validators/project');
+
+const createRandomStr = () => Math.random().toString(36).substring(2, 8);
+
+// project
+
+const createProject = async ({ did, type, blockletTitle, blockletDid, manager }) => {
+  await titleSchema.validateAsync(blockletTitle);
+  validateNewDid(blockletDid);
+  if (!PROJECT.TYPES[type]) {
+    throw new Error(`type is invalid: ${type}`);
+  }
+
+  const blocklet = await manager.getBlocklet(did, { useCache: true });
+  const { projectState } = await manager._getProjectState(did);
+
+  const project = await projectState.createProject({ blockletTitle, blockletDid, type });
+
+  // create project dir
+  const projectDir = path.join(blocklet.env.dataDir, PROJECT.DIR, `${project.id}`);
+  const releasesDir = path.join(projectDir, PROJECT.RELEASE_DIR);
+  const tmpResourceDir = path.join(projectDir, PROJECT.RESOURCE_DIR);
+  const assetDir = path.join(projectDir, PROJECT.ASSET_DIR);
+  await fs.ensureDir(releasesDir);
+  await fs.ensureDir(tmpResourceDir);
+  await fs.ensureDir(assetDir);
+
+  return project;
+};
+
+const getProjects = async ({ did, manager }) => {
+  const { projectState } = await manager._getProjectState(did);
+  const projects = await projectState.getProjects();
+  return { projects };
+};
+
+const getProject = async ({ did, projectId, manager }) => {
+  const { projectState } = await manager._getProjectState(did);
+  const project = await projectState.findOne({ id: projectId });
+  return project;
+};
+
+const updateProject = async ({ did, projectId, manager, ...params }) => {
+  const { projectState } = await manager._getProjectState(did);
+  const project = await projectState.updateProject(projectId, params);
+  return project;
+};
+
+const deleteProject = async ({ did, projectId, manager }) => {
+  if (!projectId) {
+    throw new Error('projectId is required');
+  }
+  const { projectState, releaseState } = await manager._getProjectState(did);
+  const blocklet = await manager.getBlocklet(did);
+  const projectDir = path.join(blocklet.env.dataDir, PROJECT.DIR, `${projectId}`);
+
+  await projectState.remove({ id: projectId });
+  await releaseState.remove({ projectId });
+  await fs.remove(projectDir);
+};
+
+// release
+const getReleases = async ({ did, projectId, manager }) => {
+  const { releaseState } = await manager._getProjectState(did);
+  const releases = await releaseState.getReleases({ projectId });
+  return { releases };
+};
+const getRelease = async ({ did, projectId, releaseId, manager }) => {
+  const { releaseState } = await manager._getProjectState(did);
+  const release = await releaseState.findOne({ projectId, id: releaseId });
+  return release;
+};
+const deleteRelease = async ({ did, projectId, releaseId, manager }) => {
+  if (!projectId) {
+    throw new Error('projectId is required');
+  }
+  if (!releaseId) {
+    throw new Error('releaseId is required');
+  }
+
+  const blocklet = await manager.getBlocklet(did);
+  const { releaseState } = await manager._getProjectState(did);
+  const releaseDir = path.join(blocklet.env.dataDir, PROJECT.DIR, `${projectId}`, PROJECT.RELEASE_DIR, `${releaseId}`);
+
+  await releaseState.remove({ projectId, id: releaseId });
+  await fs.remove(releaseDir);
+};
+
+const createRelease = async ({
+  did,
+  projectId,
+  releaseId,
+  blockletTitle,
+  blockletDescription,
+  blockletVersion,
+  blockletIntroduction,
+  blockletLogo,
+  blockletScreenshots,
+  note,
+  manager,
+  status,
+}) => {
+  if (!projectId) {
+    throw new Error('projectId is required');
+  }
+  if (!PROJECT.RELEASE_STATUS[status]) {
+    throw new Error(`status is invalid: ${status}`);
+  }
+
+  const params = {
+    blockletVersion,
+    blockletTitle,
+    blockletDescription,
+    blockletLogo,
+    blockletIntroduction,
+    blockletScreenshots,
+    note,
+  };
+
+  const releaseSchema = createReleaseSchema(status);
+  await releaseSchema.validateAsync(params);
+
+  const blocklet = await manager.getBlocklet(did);
+  const { projectState, releaseState } = await manager._getProjectState(did);
+
+  const project = await projectState.findOne({ id: projectId });
+  if (!project) {
+    throw new Error('project not found');
+  }
+
+  const action = releaseId ? 'update' : 'create';
+
+  if (action === 'update') {
+    const release = await releaseState.findOne({ projectId, id: releaseId });
+    if (!release) {
+      throw new Error('release not found');
+    }
+    if (release.status !== 'draft') {
+      throw new Error('Can not update a published release');
+    }
+  }
+
+  const existVersion = await releaseState.findOne({ projectId, blockletVersion });
+  if (existVersion && (action === 'create' || existVersion.id !== releaseId)) {
+    throw new Error(`blockletVersion ${blockletVersion} already exists`);
+  }
+
+  const { blockletDid } = project;
+
+  params.blockletDid = blockletDid;
+
+  const release = await releaseState.upsertRelease({
+    ...params,
+    projectId,
+    releaseId,
+    status,
+  });
+  await projectState.updateProject(projectId, params);
+
+  const _releaseId = release.id;
+
+  const projectDir = path.join(blocklet.env.dataDir, PROJECT.DIR, `${projectId}`);
+  const tmpDir = path.join(manager.dataDirs.tmp, PROJECT.DIR, `${blockletDid}-${createRandomStr()}`);
+  const releaseDir = path.join(projectDir, PROJECT.RELEASE_DIR, `${_releaseId}`);
+  const resourceDir = path.join(releaseDir, PROJECT.RESOURCE_DIR);
+  const tmpResourceDir = path.join(projectDir, PROJECT.RESOURCE_DIR);
+
+  await fs.ensureDir(releaseDir);
+
+  // move tmp resource to release
+  if (action === 'create') {
+    await fs.ensureDir(tmpResourceDir);
+    await fs.remove(releaseDir);
+    await fs.ensureDir(releaseDir);
+    await fs.move(tmpResourceDir, resourceDir);
+    await fs.ensureDir(tmpResourceDir);
+  }
+
+  if (status === PROJECT.RELEASE_STATUS.draft) {
+    return release;
+  }
+
+  // create a release
+  if (fs.existsSync(tmpDir)) {
+    await fs.remove(tmpDir);
+  }
+
+  const tmpExportDir = path.join(tmpDir, 'export');
+  const tmpBundleDir = path.join(tmpExportDir, 'bundle');
+
+  const moniker = (urlPathFriendly(slugify(release.blockletTitle)) || 'blocklet').toLowerCase();
+  const releaseFileName = `${moniker}-${release.blockletVersion}.zip`;
+  const releaseFile = path.join(releaseDir, releaseFileName);
+  if (fs.existsSync(releaseFile)) {
+    logger.error('release file already exists, remove it', releaseFile);
+    await fs.remove(releaseFile);
+  }
+
+  try {
+    await fs.ensureDir(tmpBundleDir);
+
+    // create logo
+    const logoFile = project.blockletLogo
+      ? path.join(projectDir, PROJECT.ASSET_DIR, project.blockletLogo)
+      : path.join(__dirname, 'logo.png');
+    const logoExt = path.extname(logoFile);
+    const logoFileName = `logo${logoExt}`;
+    await fs.copy(logoFile, path.join(tmpBundleDir, logoFileName));
+
+    // create screenshots
+    const screenshotsDistDir = path.join(tmpBundleDir, 'screenshots');
+    await fs.ensureDir(screenshotsDistDir);
+    if (project.blockletScreenshots?.length) {
+      await Promise.all(
+        project.blockletScreenshots.map(async (screenshot) => {
+          const screenshotFile = path.join(projectDir, PROJECT.ASSET_DIR, screenshot);
+          await fs.copy(screenshotFile, path.join(screenshotsDistDir, screenshot));
+        })
+      );
+    }
+
+    // create readme
+    if (blockletIntroduction) {
+      await fs.outputFile(path.join(tmpBundleDir, 'README.md'), blockletIntroduction);
+    }
+
+    // create blocklet.yml
+    const meta = {
+      did: blockletDid,
+      name: blockletDid,
+      title: blockletTitle,
+      description: blockletDescription,
+      version: blockletVersion,
+      logo: logoFileName,
+      resources: ['/resource'],
+      components: [],
+      files: ['screenshots'],
+      screenshots: project.blockletScreenshots || [],
+    };
+
+    await updateMetaFile(path.join(tmpBundleDir, BLOCKLET_META_FILE), meta);
+
+    // changelog
+    const changelogDistFile = path.join(tmpBundleDir, 'CHANGELOG.md');
+    const releases = await releaseState.getReleases({ projectId, status: PROJECT.RELEASE_STATUS.published });
+    const changelog = releases.map((_release) => {
+      const { blockletVersion: version, note: content } = _release;
+      return `## ${version}\n\n${content}`;
+    });
+    await fs.outputFile(changelogDistFile, changelog.join('\n\n'));
+
+    // create resource
+    await fs.ensureDir(resourceDir);
+    await fs.copy(resourceDir, path.join(tmpBundleDir, 'resource'));
+
+    // copy resource to tmpResourceDir
+    await fs.remove(tmpResourceDir);
+    await fs.copy(resourceDir, tmpResourceDir);
+
+    // create release
+    await createBlockletRelease(tmpExportDir, { printError: logger.error, printInfo: logger.info });
+
+    // archive
+    const archive = createArchive('zip', { zlib: { level: 9 } });
+    const writeStream = fs.createWriteStream(releaseFile);
+
+    await new Promise((resolve, reject) => {
+      archive
+        .directory(tmpExportDir, false)
+        .on('error', (err) => reject(err))
+        .pipe(writeStream);
+
+      writeStream.on('close', () => resolve(releaseFile));
+      archive.finalize();
+    });
+
+    const res2 = await releaseState.upsertRelease({
+      projectId,
+      releaseId: _releaseId,
+      files: [releaseFileName],
+    });
+
+    await fs.remove(tmpDir);
+
+    logger.info('create release success', res2);
+
+    return res2;
+  } catch (error) {
+    await fs.remove(tmpDir);
+    await fs.remove(releaseFile);
+    if (action === 'create') {
+      await fs.remove(releaseDir);
+      await releaseState.remove({ projectId, id: _releaseId });
+    } else {
+      await releaseState.update({ id: _releaseId }, { $set: { status: PROJECT.RELEASE_STATUS.draft } });
+    }
+    logger.error(`export ${project.type} error`, error);
+    throw error;
+  }
+};
+
+module.exports = {
+  createProject,
+  getProjects,
+  getProject,
+  updateProject,
+  deleteProject,
+  createRelease,
+  getReleases,
+  getRelease,
+  deleteRelease,
+};

package/lib/index.js

@@ -278,6 +278,17 @@ function ABTNode(options) {
     migrateApplicationToStructV2: blockletManager.migrateApplicationToStructV2.bind(blockletManager),
     syncAppConfig: blockletManager.syncAppConfig.bind(blockletManager),
 
+    // blocklet project
+    createProject: blockletManager.createProject.bind(blockletManager),
+    deleteProject: blockletManager.deleteProject.bind(blockletManager),
+    getProjects: blockletManager.getProjects.bind(blockletManager),
+    getProject: blockletManager.getProject.bind(blockletManager),
+    updateProject: blockletManager.updateProject.bind(blockletManager),
+    createRelease: blockletManager.createRelease.bind(blockletManager),
+    getReleases: blockletManager.getReleases.bind(blockletManager),
+    getRelease: blockletManager.getRelease.bind(blockletManager),
+    deleteRelease: blockletManager.deleteRelease.bind(blockletManager),
+
     // For diagnose purpose
     syncBlockletStatus: blockletManager.status.bind(blockletManager),
     ensureBlockletIntegrity: blockletManager.ensureBlocklet.bind(blockletManager),

package/lib/router/helper.js

@@ -1209,6 +1209,8 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
 
   const providers = {}; // we need to keep reference for different router instances
   const handleRouting = async (nodeInfo) => {
+    const now = Date.now();
+    logger.info('start handle routing');
     const providerName = get(nodeInfo, 'routing.provider', null);
     const httpsEnabled = get(nodeInfo, 'routing.https', true);
     logger.debug('handle routing', { providerName, httpsEnabled });
@@ -1272,6 +1274,8 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
 
       await providers[providerName].start();
     }
+
+    logger.info('done handle routing', { cost: Date.now() - now });
   };
 
   const rotateRouterLog = async () => {

package/lib/states/project.js

@@ -0,0 +1,45 @@
+const pickBy = require('lodash/pickBy');
+const pick = require('lodash/pick');
+const BaseState = require('./base');
+
+const isUndefinedOrNull = (x) => x === undefined || x === null;
+
+/**
+ * @extends BaseState<import('@abtnode/models').ProjectState>
+ */
+class Project extends BaseState {
+  createProject({ type, blockletDid, blockletTitle }) {
+    return this.insert({ id: blockletDid, type, blockletDid, blockletTitle });
+  }
+
+  getProjects() {
+    return this.find(
+      {},
+      {},
+      {
+        createdAt: -1,
+      }
+    );
+  }
+
+  async updateProject(id, params) {
+    const _params = pickBy(
+      pick(params, [
+        'name',
+        'blockletLogo',
+        'blockletVersion',
+        'blockletIntroduction',
+        'blockletTitle',
+        'blockletDescription',
+        'blockletDid',
+        'blockletScreenshots',
+      ]),
+      (x) => !isUndefinedOrNull(x)
+    );
+
+    const [, [updated]] = await this.update({ id }, { $set: _params });
+    return updated;
+  }
+}
+
+module.exports = Project;

package/lib/states/release.js

@@ -0,0 +1,46 @@
+const pick = require('lodash/pick');
+const BaseState = require('./base');
+
+/**
+ * @extends BaseState<import('@abtnode/models').ReleaseState>
+ */
+class Release extends BaseState {
+  getReleases({ projectId, status } = {}) {
+    const query = { projectId };
+    if (status) {
+      query.status = status;
+    }
+    return this.find(
+      query,
+      {},
+      {
+        createdAt: -1,
+      }
+    );
+  }
+
+  async upsertRelease({ releaseId, ...params }) {
+    const _params = pick(params, [
+      'projectId',
+      'blockletDid',
+      'blockletVersion',
+      'blockletTitle',
+      'blockletDescription',
+      'blockletLogo',
+      'blockletIntroduction',
+      'blockletScreenshots',
+      'note',
+      'status',
+      'files',
+    ]);
+
+    if (!releaseId) {
+      return this.insert(_params);
+    }
+
+    const [, [updated]] = await this.update({ id: releaseId }, { $set: _params });
+    return updated;
+  }
+}
+
+module.exports = Release;

package/lib/team/manager.js

@@ -32,6 +32,8 @@ const States = {
   ConnectedAccount: require('../states/connect-account'),
   Session: require('../states/session'),
   Tag: require('../states/tag'),
+  Project: require('../states/project'),
+  Release: require('../states/release'),
 };
 
 const getDefaultTeamState = () => ({
@@ -41,6 +43,8 @@ const getDefaultTeamState = () => ({
   connectedAccount: null,
   session: null,
   tag: null,
+  project: null,
+  release: null,
 });
 
 class TeamManager extends EventEmitter {
@@ -119,6 +123,13 @@ class TeamManager extends EventEmitter {
     return this.getState(teamDid, 'session');
   }
 
+  async getProjectState(teamDid) {
+    return {
+      projectState: await this.getState(teamDid, 'project'),
+      releaseState: await this.getState(teamDid, 'release'),
+    };
+  }
+
   async getState(teamDid, key) {
     const pid = await this.getPid(teamDid);
     if (!pid) {

package/lib/util/blocklet.js

@@ -1723,6 +1723,10 @@ const getBlockletStatus = (blocklet) => {
       return;
     }
 
+    if (status === BlockletStatus.stopped) {
+      return;
+    }
+
     status = component.status;
   });
 

package/lib/util/store.js

@@ -111,7 +111,7 @@ const parseSourceUrl = async (url) => {
         };
       }
     } catch {
-      // meat is not in store, do nothing
+      // meta is not in store, do nothing
     }
   }
 

package/lib/validators/project.js

@@ -0,0 +1,29 @@
+const { Joi, titleSchema, descriptionSchema } = require('@blocklet/meta/lib/schema');
+const { PROJECT } = require('@blocklet/constant');
+
+const note = Joi.string().min(1).max(1000);
+const blockletIntroduction = Joi.string().max(3000).allow('').allow(null);
+const blockletScreenshots = Joi.array().items(Joi.string().min(1).max(200));
+const blockletLogo = Joi.string().max(200).allow(null).allow('');
+
+const createReleaseSchema = (status) =>
+  Joi.object({
+    note: status === PROJECT.RELEASE_STATUS.published ? note.required() : note.allow(''),
+    blockletVersion: Joi.semver().valid().required(),
+    blockletTitle: titleSchema.required(),
+    blockletDescription:
+      status === PROJECT.RELEASE_STATUS.published
+        ? descriptionSchema.required()
+        : descriptionSchema.allow('').allow(null),
+    blockletScreenshots,
+    blockletIntroduction,
+    blockletLogo,
+  });
+
+module.exports = {
+  note,
+  blockletIntroduction,
+  blockletScreenshots,
+  blockletLogo,
+  createReleaseSchema,
+};

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.16.16",
+  "version": "1.16.17-beta-8cacb9b3",
   "description": "",
   "main": "lib/index.js",
   "files": [
@@ -19,39 +19,39 @@
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
   "license": "Apache-2.0",
   "dependencies": {
-    "@abtnode/analytics": "1.16.16",
-    "@abtnode/auth": "1.16.16",
-    "@abtnode/certificate-manager": "1.16.16",
-    "@abtnode/constant": "1.16.16",
-    "@abtnode/cron": "1.16.16",
-    "@abtnode/logger": "1.16.16",
-    "@abtnode/models": "1.16.16",
-    "@abtnode/queue": "1.16.16",
-    "@abtnode/rbac": "1.16.16",
-    "@abtnode/router-provider": "1.16.16",
-    "@abtnode/static-server": "1.16.16",
-    "@abtnode/timemachine": "1.16.16",
-    "@abtnode/util": "1.16.16",
-    "@arcblock/did": "1.18.90",
-    "@arcblock/did-auth": "1.18.90",
-    "@arcblock/did-ext": "^1.18.90",
+    "@abtnode/analytics": "1.16.17-beta-8cacb9b3",
+    "@abtnode/auth": "1.16.17-beta-8cacb9b3",
+    "@abtnode/certificate-manager": "1.16.17-beta-8cacb9b3",
+    "@abtnode/constant": "1.16.17-beta-8cacb9b3",
+    "@abtnode/cron": "1.16.17-beta-8cacb9b3",
+    "@abtnode/logger": "1.16.17-beta-8cacb9b3",
+    "@abtnode/models": "1.16.17-beta-8cacb9b3",
+    "@abtnode/queue": "1.16.17-beta-8cacb9b3",
+    "@abtnode/rbac": "1.16.17-beta-8cacb9b3",
+    "@abtnode/router-provider": "1.16.17-beta-8cacb9b3",
+    "@abtnode/static-server": "1.16.17-beta-8cacb9b3",
+    "@abtnode/timemachine": "1.16.17-beta-8cacb9b3",
+    "@abtnode/util": "1.16.17-beta-8cacb9b3",
+    "@arcblock/did": "1.18.91",
+    "@arcblock/did-auth": "1.18.91",
+    "@arcblock/did-ext": "^1.18.91",
     "@arcblock/did-motif": "^1.1.13",
-    "@arcblock/did-util": "1.18.90",
-    "@arcblock/event-hub": "1.18.90",
-    "@arcblock/jwt": "^1.18.90",
+    "@arcblock/did-util": "1.18.91",
+    "@arcblock/event-hub": "1.18.91",
+    "@arcblock/jwt": "^1.18.91",
     "@arcblock/pm2-events": "^0.0.5",
-    "@arcblock/validator": "^1.18.90",
-    "@arcblock/vc": "1.18.90",
-    "@blocklet/constant": "1.16.16",
-    "@blocklet/env": "1.16.16",
-    "@blocklet/meta": "1.16.16",
-    "@blocklet/resolver": "1.16.16",
-    "@blocklet/sdk": "1.16.16",
+    "@arcblock/validator": "^1.18.91",
+    "@arcblock/vc": "1.18.91",
+    "@blocklet/constant": "1.16.17-beta-8cacb9b3",
+    "@blocklet/env": "1.16.17-beta-8cacb9b3",
+    "@blocklet/meta": "1.16.17-beta-8cacb9b3",
+    "@blocklet/resolver": "1.16.17-beta-8cacb9b3",
+    "@blocklet/sdk": "1.16.17-beta-8cacb9b3",
     "@did-space/client": "^0.3.8",
     "@fidm/x509": "^1.2.1",
-    "@ocap/mcrypto": "1.18.90",
-    "@ocap/util": "1.18.90",
-    "@ocap/wallet": "1.18.90",
+    "@ocap/mcrypto": "1.18.91",
+    "@ocap/util": "1.18.91",
+    "@ocap/wallet": "1.18.91",
     "@slack/webhook": "^5.0.4",
     "archiver": "^5.3.1",
     "axios": "^0.27.2",
@@ -70,6 +70,7 @@
     "is-base64": "^1.1.0",
     "is-url": "^1.2.4",
     "joi": "17.7.0",
+    "joi-extension-semver": "^5.0.0",
     "js-yaml": "^4.1.0",
     "kill-port": "^2.0.1",
     "lodash": "^4.17.21",
@@ -100,5 +101,5 @@
     "jest": "^27.5.1",
     "unzipper": "^0.10.11"
   },
-  "gitHead": "2de4f6dbad086bd861273a4fc9ca8a87ddda4778"
+  "gitHead": "0e3266f543b6d419a004ca94ee9efb572e3d9809"
 }