@abtnode/util 1.16.43-beta-20250422-042711-c40bec75 → 1.16.43-beta-20250425-130658-8da18f4d

package/lib/auth-simple-access-key.js

@@ -0,0 +1,90 @@
+const { fromPublicKey } = require('@ocap/wallet');
+const { fromBase58 } = require('@ocap/util');
+const { isSystemRole } = require('@abtnode/constant');
+
+const checkAccessKeySource = async ({ node, keyId, info, blockletDid }) => {
+  let teamDid = info.did;
+  let accessKey = await node.getAccessKey({ teamDid, accessKeyId: keyId }).catch(() => null);
+  let isFromBlocklet;
+
+  if (blockletDid && !accessKey) {
+    isFromBlocklet = true;
+    teamDid = blockletDid;
+    accessKey = await node.getAccessKey({ teamDid, accessKeyId: keyId }).catch(() => null);
+  }
+
+  return { teamDid, isFromBlocklet, accessKey };
+};
+
+const isLoginToken = (token) => {
+  return !!token && typeof token === 'string' && token.split('.').length === 3;
+};
+
+const isAccessKey = (token) => {
+  return !!token && typeof token === 'string' && token.split('.').length === 1 && token.startsWith('blocklet-');
+};
+
+const authBySimpleAccessKey = async (token, node, blockletDid = '') => {
+  const info = await node.getNodeInfo({ useCache: true });
+
+  const secret = token.replace('blocklet-', '');
+
+  let publicKey = '';
+  try {
+    publicKey = fromBase58(secret);
+  } catch (error) {
+    publicKey = '';
+  }
+
+  if (!publicKey) {
+    throw new Error('Invalid access key secret');
+  }
+
+  const wallet = fromPublicKey(publicKey);
+  if (!wallet) {
+    throw new Error('Invalid access key secret');
+  }
+
+  const accessKeyId = wallet.address;
+
+  const { teamDid, isFromBlocklet, accessKey } = await checkAccessKeySource({
+    node,
+    keyId: accessKeyId,
+    info,
+    blockletDid,
+  });
+
+  const { passport, remark, expireAt, authType } = accessKey;
+
+  if (authType !== 'simple') {
+    throw new Error(`Access Key ${accessKeyId} is not a simple type`);
+  }
+
+  if (expireAt && new Date(expireAt).getTime() < new Date().getTime()) {
+    throw new Error(`Access Key ${accessKeyId} has expired`);
+  }
+
+  if (!accessKey.createdBy) {
+    throw new Error(`Access Key ${accessKeyId} is not created by a user`);
+  }
+
+  await node.refreshLastUsed({ teamDid, accessKeyId });
+
+  const role = passport;
+  const blockletRole = isSystemRole(role) ? `blocklet-${role}` : role;
+
+  return {
+    did: accessKey.createdBy,
+    role: isFromBlocklet ? blockletRole : role,
+    elevated: true,
+    blockletDid: teamDid,
+    fullName: remark || accessKeyId,
+  };
+};
+
+module.exports = {
+  checkAccessKeySource,
+  authBySimpleAccessKey,
+  isLoginToken,
+  isAccessKey,
+};

package/lib/check-file.js

@@ -0,0 +1,57 @@
+const { minimatch } = require('minimatch');
+
+const checkMatch = (file, match) => {
+  let m = match;
+  if (!m.includes('*')) {
+    return false;
+  }
+  if (!m.endsWith('*')) {
+    return minimatch(file, m);
+  }
+  if (!m.endsWith('**')) {
+    m = `${m}*`;
+  }
+
+  return minimatch(file, m);
+};
+
+const checkInclude = (list, f) =>
+  f === '.' ||
+  f === '' || // root folder maybe '.' and ''
+  list.some(
+    (x) =>
+      x.indexOf(f) === 0 || // f is 'website' && x is 'website/public'
+      f.indexOf(x) === 0 || // f is website/public/index.html && x is website/public
+      checkMatch(f, x) // f is hooks/pre-start.js && x is hooks/*
+  );
+
+/**
+ * Whether a file should be deployed
+ * @param {string} file a file will be deployed
+ * @param {object} opts
+ * @param {array<string>} opts.diffList
+ * @param {BundleType} opts.bundleType
+ * @param {array<string>} opts.staticList
+ * @return {boolean} Should this file be deployed
+ */
+const fileFilter = (file, opts = {}) => {
+  const { diffList, bundleType, staticList } = opts;
+  // only include diffList if has one
+  if (diffList) {
+    return checkInclude(diffList, file);
+  }
+  // only include staticList if bundleType is static
+  if (bundleType === 'static') {
+    if (!staticList) {
+      throw new Error('staticList should not be empty when bundleType is static');
+    }
+    return checkInclude(staticList, file);
+  }
+  // include all files
+  return true;
+};
+
+module.exports = {
+  fileFilter,
+  checkMatch,
+};

package/lib/ensure-server-endpoint.js

@@ -0,0 +1,59 @@
+const { joinURL } = require('ufo');
+const { default: axios } = require('axios');
+const { WELLKNOWN_DID_RESOLVER_PREFIX } = require('@abtnode/constant');
+const { getDidDomainForBlocklet } = require('./get-domain-for-blocklet');
+
+const BLOCKLET_JSON_PATH = '__blocklet__.js?type=json';
+
+const ensureServerEndpoint = async (endpoint) => {
+  let serverBaseUrl;
+  let appPid;
+  let appName;
+  let appDescription;
+
+  const jsonPathUrl = joinURL(new URL(endpoint).origin, BLOCKLET_JSON_PATH);
+
+  const checkEndpoint = await axios(jsonPathUrl).catch(() => null);
+  const contentType = checkEndpoint && checkEndpoint.headers['content-type'];
+  if (contentType?.includes('application/json')) {
+    const url = getDidDomainForBlocklet({ did: checkEndpoint.data.serverDid });
+    // service endpoint
+    serverBaseUrl = new URL(`https://${url}`).origin;
+    appPid = checkEndpoint.data.appPid;
+    appName = checkEndpoint.data.appName;
+    appDescription = checkEndpoint.data.appDescription;
+  } else {
+    // maybe server endpoint
+    serverBaseUrl = new URL(endpoint).origin;
+    appPid = '';
+  }
+
+  if (!serverBaseUrl) {
+    throw new Error('Invalid endpoint');
+  }
+
+  // local debug
+  if (serverBaseUrl.includes('localhost:3000')) {
+    return {
+      endpoint: serverBaseUrl,
+      appPid,
+    };
+  }
+
+  const didJsonUrl = joinURL(serverBaseUrl, WELLKNOWN_DID_RESOLVER_PREFIX);
+  const didJson = await axios(didJsonUrl);
+
+  const didJsonContentType = didJson.headers['content-type'];
+  if (!didJsonContentType.includes('application/json')) {
+    throw new Error('Invalid endpoint');
+  }
+
+  return {
+    endpoint: joinURL(serverBaseUrl, didJson?.data?.services?.[0]?.path),
+    appPid,
+    appName,
+    appDescription,
+  };
+};
+
+module.exports = ensureServerEndpoint;

package/lib/get-origin.js

@@ -2,11 +2,11 @@ const defaultLogger = {
   error: console.error,
 };
 
-async function getOrigin({ req }, { printError = defaultLogger.error } = {}) {
+async function getOrigin({ req, blockletInfo }, { printError = defaultLogger.error } = {}) {
   try {
     if (req.getBlockletInfo) {
-      const blockletInfo = await req.getBlockletInfo();
-      return blockletInfo.appUrl;
+      const _blockletInfo = blockletInfo || (await req.getBlockletInfo());
+      return _blockletInfo.appUrl;
     }
     const host = req.get('host');
     return `https://${host}`;

package/lib/make-from-data.js

@@ -0,0 +1,62 @@
+const fs = require('fs');
+const FormData = require('form-data');
+
+const makeFormData = ({ tarFile: file, hasDiff, did, serverVersion, deleteSet, rootDid, mountPoint }) => {
+  let varFields = hasDiff
+    ? '$file: Upload!, $did: String, $diffVersion: String, $deleteSet: [String!]'
+    : '$file: Upload!';
+  let inputFields = hasDiff
+    ? 'file: $file, did: $did, diffVersion: $diffVersion, deleteSet: $deleteSet'
+    : 'file: $file';
+
+  varFields = `${varFields}, $rootDid: String, $mountPoint: String`;
+  inputFields = `${inputFields}, rootDid: $rootDid, mountPoint: $mountPoint`;
+
+  const variables = hasDiff
+    ? {
+        file: null,
+        did,
+        diffVersion: serverVersion,
+        deleteSet,
+      }
+    : {
+        file: null,
+      };
+
+  variables.rootDid = rootDid;
+  variables.mountPoint = mountPoint;
+
+  const apiName = 'installComponent';
+  const query = `
+    mutation (${varFields}) {
+      ${apiName}(input: { ${inputFields} } ) {
+        code
+        blocklet {
+          meta {
+            did
+            name
+            title
+            version
+            description
+          }
+          status
+          source
+        }
+      }
+    }
+  `;
+  const gql = {
+    query,
+    variables,
+  };
+  const map = {
+    file0: ['variables.file'],
+  };
+  const form = new FormData();
+  form.append('operations', JSON.stringify(gql));
+  form.append('map', JSON.stringify(map));
+  form.append('file0', fs.createReadStream(file));
+  return { form, apiName };
+};
+
+module.exports = makeFormData;

package/lib/single-flight-lru-cache.js

@@ -0,0 +1,80 @@
+const { LRUCache } = require('lru-cache');
+const pWaitFor = require('p-wait-for');
+
+const PADDING_VALUE = '__padding__';
+
+// Single flight lru cache
+// ref: https://www.codingexplorations.com/blog/understanding-singleflight-in-golang-a-solution-for-eliminating-redundant-work
+class SingleFlightLRUCache extends LRUCache {
+  paddingInterval = 100;
+
+  paddingTimeout = 10 * 1000;
+
+  setPadding(key) {
+    this.set(key, PADDING_VALUE);
+  }
+
+  isPadding(key) {
+    return this.get(key) === PADDING_VALUE;
+  }
+
+  async waitPending(key) {
+    if (this.get(key) === PADDING_VALUE) {
+      try {
+        await pWaitFor(() => this.get(key) !== PADDING_VALUE, {
+          interval: this.paddingInterval,
+          timeout: this.paddingTimeout,
+        });
+      } catch (_) {
+        if (this.get(key) === PADDING_VALUE) {
+          this.delete(key);
+        }
+      }
+    }
+    return this.get(key);
+  }
+
+  async wrapPending(key, fn) {
+    if (!key) {
+      return Promise.resolve(fn());
+    }
+    const old = this.get(key);
+    if (old) {
+      if (old === PADDING_VALUE) {
+        const result = await this.waitPending(key);
+        if (result && result !== PADDING_VALUE) {
+          return result;
+        }
+      } else {
+        return old;
+      }
+    }
+    this.setPadding(key);
+    try {
+      const result = await Promise.resolve(fn());
+      return result;
+    } finally {
+      if (this.get(key) === PADDING_VALUE) {
+        this.delete(key);
+      }
+    }
+  }
+
+  /**
+   * autoCache will set the result to the cache if the key is not null
+   * if the key is null, it will return the result of the function
+   * if the key is not null, it will return the cached result
+   * if padding, it will wait for the padding to finish
+   * if the key is not in the cache, it will set the result to the cache
+   * if the key is in the cache, it will return the cached result
+   */
+  async autoCache(key, fn) {
+    const result = await this.wrapPending(key, fn);
+    if (key) {
+      this.set(key, result);
+    }
+    return result;
+  }
+}
+
+module.exports = SingleFlightLRUCache;

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.16.43-beta-20250422-042711-c40bec75",
+  "version": "1.16.43-beta-20250425-130658-8da18f4d",
   "description": "ArcBlock's JavaScript utility",
   "main": "lib/index.js",
   "files": [
@@ -18,15 +18,15 @@
   "author": "polunzh <polunzh@gmail.com> (http://github.com/polunzh)",
   "license": "Apache-2.0",
   "dependencies": {
-    "@abtnode/constant": "1.16.43-beta-20250422-042711-c40bec75",
-    "@arcblock/did": "^1.20.1",
+    "@abtnode/constant": "1.16.43-beta-20250425-130658-8da18f4d",
+    "@arcblock/did": "^1.20.2",
     "@arcblock/pm2": "^5.4.0",
-    "@blocklet/constant": "1.16.43-beta-20250422-042711-c40bec75",
-    "@blocklet/meta": "1.16.43-beta-20250422-042711-c40bec75",
-    "@ocap/client": "1.20.1",
-    "@ocap/mcrypto": "1.20.1",
-    "@ocap/util": "1.20.1",
-    "@ocap/wallet": "1.20.1",
+    "@blocklet/constant": "1.16.43-beta-20250425-130658-8da18f4d",
+    "@blocklet/meta": "1.16.43-beta-20250425-130658-8da18f4d",
+    "@ocap/client": "1.20.2",
+    "@ocap/mcrypto": "1.20.2",
+    "@ocap/util": "1.20.2",
+    "@ocap/wallet": "1.20.2",
     "archiver": "^7.0.1",
     "axios": "^1.7.9",
     "axios-mock-adapter": "^2.1.0",
@@ -43,6 +43,7 @@
     "fkill": "^7.2.1",
     "flush-write-stream": "^2.0.0",
     "folder-walker": "^3.2.0",
+    "form-data": "^4.0.2",
     "get-folder-size": "^2.0.1",
     "hasha": "^5.2.2",
     "hpagent": "^1.1.0",
@@ -52,9 +53,12 @@
     "is-url": "^1.2.4",
     "json-stable-stringify": "^1.0.1",
     "lodash": "^4.17.21",
+    "lru-cache": "^11.0.2",
+    "minimatch": "^10.0.1",
     "multiformats": "9.9.0",
     "npm-packlist": "^7.0.4",
     "p-retry": "^4.6.2",
+    "p-wait-for": "^3.2.0",
     "parallel-transform": "^1.2.0",
     "public-ip": "^4.0.4",
     "pump": "^3.0.0",
@@ -82,5 +86,5 @@
     "fs-extra": "^11.2.0",
     "jest": "^29.7.0"
   },
-  "gitHead": "836a400c1f953f421a8e95dc9a32ba883ac2586d"
+  "gitHead": "b5195a0290d5ced00bb716a709548b1a56356134"
 }