@adobe/aem-cli 15.0.0

package/src/server/HelixImportProject.js

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2018 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+import { HelixImportServer } from './HelixImportServer.js';
+import { BaseProject } from './BaseProject.js';
+
+export class HelixImportProject extends BaseProject {
+  constructor() {
+    super(HelixImportServer);
+  }
+
+  async start() {
+    this.log.debug('Launching AEM import server for importing content...');
+    await super.start();
+    return this;
+  }
+
+  async doStop() {
+    this.log.debug('Stopping AEM import server..');
+    await super.doStop();
+  }
+}

package/src/server/HelixImportServer.js

@@ -0,0 +1,207 @@
+/*
+ * Copyright 2018 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+import { promisify } from 'util';
+import path from 'path';
+import { PassThrough } from 'stream';
+import { getFetch, resetContext } from '../fetch-utils.js';
+import utils from './utils.js';
+import RequestContext from './RequestContext.js';
+import { asyncHandler, BaseServer } from './BaseServer.js';
+
+export class HelixImportServer extends BaseServer {
+  /**
+   * Proxy Mode route handler
+   * @param {Express.Request} req request
+   * @param {Express.Response} res response
+   */
+  async handleToolsRequest(req, res) {
+    const sendFile = promisify(res.sendFile).bind(res);
+    const ctx = new RequestContext(req, this._project);
+    const { log } = this;
+
+    // try to serve static
+    try {
+      const filePath = path.join(this._project.directory, ctx.path);
+      if (path.relative(this._project.directory, filePath).startsWith('..')) {
+        log.info(`refuse to serve file outside the project directory: ${filePath}`);
+        res.status(403).send('');
+        return;
+      }
+      log.debug('trying to serve local file', filePath);
+      await sendFile(filePath, {
+        dotfiles: 'allow',
+        headers: {
+          'access-control-allow-origin': '*',
+        },
+      });
+      return;
+    } catch (e) {
+      // not sure what to do yet here
+      // codecov:ignore:start
+      /* c8 ignore start */
+      log.debug(`Error while delivering resource ${ctx.path} - ${e.stack || e}`);
+      // codecov:ignore:end
+      /* c8 ignore end */
+    }
+
+    res.status(404).send(`Unknown path: ${ctx.path}`);
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  _makeProxyURL(reqUrl, base) {
+    const url = new URL(reqUrl, base);
+    url.searchParams.delete('host');
+    return url.toString();
+  }
+
+  async _doProxyRequest(ctx, url, host, req, res) {
+    ctx.log.debug(`Proxy ${req.method} request to ${url}`);
+
+    // POST requests have a body
+    const isBodyReq = !['GET', 'HEAD'].includes(req.method);
+
+    //  do not cache  POST requests
+    if (!isBodyReq && this._project.cacheDirectory) {
+      const cached = await utils.getFromCache(
+        url,
+        this._project.cacheDirectory,
+        ctx.log,
+      );
+      if (cached) {
+        res
+          .status(cached.status)
+          .set(cached.headers)
+          .cookie('hlx-proxyhost', host)
+          .send(cached.body);
+        return;
+      }
+    }
+
+    let body;
+    // pipe body if any
+    if (isBodyReq) {
+      body = new PassThrough();
+      req.pipe(body);
+    }
+
+    const headers = {
+      ...req.headers,
+    };
+    delete headers.cookie;
+    delete headers.connection;
+    delete headers.host;
+    delete headers.referer;
+
+    const ret = await getFetch(true)(url, {
+      method: req.method,
+      headers,
+      cache: 'no-store',
+      redirect: 'manual',
+      body,
+    });
+
+    const contentType = ret.headers.get('content-type') || 'text/plain';
+    const level = utils.status2level(ret.status, true);
+    ctx.log[level](`Proxy ${req.method} request to ${url}: ${ret.status} (${contentType})`);
+
+    // because fetch decodes the response, we need to reset content encoding and length
+    const respHeaders = Object.fromEntries(ret.headers.entries());
+    delete respHeaders['content-encoding'];
+    delete respHeaders['content-length'];
+
+    // remove security "constraints"
+    delete respHeaders['x-frame-options'];
+    delete respHeaders['content-security-policy'];
+    respHeaders['access-control-allow-origin'] = '*';
+    delete respHeaders['set-cookie'];
+
+    if (respHeaders.location && !respHeaders.location.startsWith('/')) {
+      const u = new URL(respHeaders.location);
+      if (u.origin === host) {
+        respHeaders.location = u.pathname;
+      }
+    }
+
+    let buffer = await ret.buffer();
+    if (contentType.includes('html') || contentType.includes('text')) {
+      buffer = utils.rewriteUrl(buffer, host);
+    }
+
+    if (!isBodyReq && this._project.cacheDirectory) {
+      await utils.writeToCache(
+        url,
+        this._project.cacheDirectory,
+        {
+          body: buffer,
+          headers: respHeaders,
+          status: ret.status,
+        },
+        ctx.log,
+      );
+    }
+
+    res
+      .status(ret.status)
+      .set(respHeaders)
+      .cookie('hlx-proxyhost', host)
+      .send(buffer);
+    ret.body.pipe(res);
+  }
+
+  /**
+   * Proxy Mode route handler
+   * @param {Express.Request} req request
+   * @param {Express.Response} res response
+   */
+  async handleProxyModeRequest(req, res) {
+    const ctx = new RequestContext(req, this._project);
+    const { log } = this;
+
+    let host = ctx.params?.host;
+    if (!host) {
+      // first call sets the cookie, next calls use the cookie
+      host = req.cookies['hlx-proxyhost'];
+    }
+
+    if (!host) {
+      res.status(403).send('Missing host parameter');
+    } else {
+      try {
+        host = new URL(host).origin;
+        const url = this._makeProxyURL(ctx.url, host);
+        await this._doProxyRequest(ctx, url, host, req, res);
+      // codecov:ignore:start
+      /* c8 ignore start */
+      } catch (err) {
+        log.error(`Failed to proxy AEM request ${ctx.path}: ${err.message}`);
+        res.status(502).send(`Failed to proxy AEM request: ${err.message}`);
+      }
+      // codecov:ignore:end
+      /* c8 ignore end */
+    }
+
+    this.emit('request', req, res, ctx);
+  }
+
+  async setupApp() {
+    await super.setupApp();
+    this.app.get('/tools/*', asyncHandler(this.handleToolsRequest.bind(this)));
+    const handler = asyncHandler(this.handleProxyModeRequest.bind(this));
+    this.app.get('*', handler);
+    this.app.post('*', handler);
+  }
+
+  async doStop() {
+    await super.doStop();
+    await resetContext();
+  }
+}

package/src/server/HelixProject.js

@@ -0,0 +1,130 @@
+/*
+ * Copyright 2018 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+import { resolve } from 'path';
+import { lstat } from 'fs/promises';
+import { HelixServer } from './HelixServer.js';
+import { BaseProject } from './BaseProject.js';
+import HeadHtmlSupport from './HeadHtmlSupport.js';
+import Indexer from './Indexer.js';
+
+export class HelixProject extends BaseProject {
+  constructor() {
+    super(HelixServer);
+    this._proxyUrl = null;
+    this._headHtml = null;
+    this._indexer = null;
+    this._printIndex = false;
+    this._file404html = null;
+  }
+
+  withLiveReload(value) {
+    this._server.withLiveReload(value);
+    return this;
+  }
+
+  withProxyUrl(value) {
+    this._proxyUrl = value;
+    return this;
+  }
+
+  withPrintIndex(value) {
+    this._printIndex = value;
+    return this;
+  }
+
+  get proxyUrl() {
+    return this._proxyUrl;
+  }
+
+  get indexer() {
+    return this._indexer;
+  }
+
+  get liveReload() {
+    // eslint-disable-next-line no-underscore-dangle
+    return this._server._liveReload;
+  }
+
+  get file404html() {
+    return this._file404html;
+  }
+
+  get headHtml() {
+    return this._headHtml;
+  }
+
+  async init() {
+    await super.init();
+    this._indexer = new Indexer()
+      .withLogger(this._logger)
+      .withCwd(this._cwd)
+      .withPrintIndex(this._printIndex);
+    return this;
+  }
+
+  async initHeadHtml() {
+    if (this.proxyUrl) {
+      this._headHtml = new HeadHtmlSupport({
+        directory: this.directory,
+        log: this.log,
+        proxyUrl: this.proxyUrl,
+      });
+      await this._headHtml.init();
+
+      // register local head in live-reload
+      if (this.liveReload) {
+        this.liveReload.registerFiles([this._headHtml.filePath], '/');
+        this.liveReload.on('modified', async (modified) => {
+          if (modified.indexOf('/') >= 0) {
+            await this._headHtml.loadLocal();
+            await this._headHtml.init();
+          }
+        });
+      }
+    }
+  }
+
+  async init404Html() {
+    if (this.proxyUrl) {
+      this._file404html = resolve(this.directory, '404.html');
+      try {
+        await lstat(this._file404html);
+        this.log.debug('detected local 404.html');
+        if (this.liveReload) {
+          this.liveReload.registerFiles([this._file404html], '/');
+        }
+      } catch (e) {
+        this._file404html = null;
+      }
+    }
+  }
+
+  async start() {
+    this.log.debug('Launching AEM dev server...');
+    await super.start();
+    await this.initHeadHtml();
+    await this.init404Html();
+    if (this._indexer) {
+      await this._indexer.init();
+    }
+    return this;
+  }
+
+  async doStop() {
+    this.log.debug('Stopping AEM dev server...');
+    await super.doStop();
+    if (this._indexer) {
+      await this._indexer.close();
+      delete this._indexer;
+    }
+  }
+}

package/src/server/HelixServer.js

@@ -0,0 +1,120 @@
+/*
+ * Copyright 2018 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+import { promisify } from 'util';
+import path from 'path';
+import compression from 'compression';
+import utils from './utils.js';
+import RequestContext from './RequestContext.js';
+import { asyncHandler, BaseServer } from './BaseServer.js';
+import LiveReload from './LiveReload.js';
+
+export class HelixServer extends BaseServer {
+  /**
+   * Creates a new HelixServer for the given project.
+   * @param {HelixProject} project
+   */
+  constructor(project) {
+    super(project);
+    this._liveReload = null;
+    this._enableLiveReload = false;
+    this._app.use(compression());
+  }
+
+  withLiveReload(value) {
+    this._enableLiveReload = value;
+    return this;
+  }
+
+  /**
+   * Proxy Mode route handler
+   * @param {Express.Request} req request
+   * @param {Express.Response} res response
+   */
+  async handleProxyModeRequest(req, res) {
+    const sendFile = promisify(res.sendFile).bind(res);
+    const ctx = new RequestContext(req, this._project);
+    const { log } = this;
+    const proxyUrl = new URL(this._project.proxyUrl);
+
+    const filePath = path.join(this._project.directory, ctx.path);
+    if (path.relative(this._project.directory, filePath).startsWith('..')) {
+      log.info(`refuse to serve file outside the project directory: ${filePath}`);
+      res.status(403).send('');
+      return;
+    }
+
+    const liveReload = this._liveReload;
+    if (liveReload) {
+      liveReload.startRequest(ctx.requestId, ctx.path);
+    }
+
+    // try to serve static
+    try {
+      log.debug('trying to serve local file', filePath);
+      await sendFile(filePath, {
+        dotfiles: 'allow',
+        headers: {
+          'access-control-allow-origin': '*',
+        },
+      });
+      if (liveReload) {
+        liveReload.registerFile(ctx.requestId, filePath);
+      }
+      return;
+    } catch (e) {
+      log.debug(`Error while delivering resource ${ctx.path} - ${e.stack || e}`);
+    } finally {
+      if (liveReload) {
+        liveReload.endRequest(ctx.requestId);
+      }
+    }
+
+    // use proxy
+    try {
+      const url = new URL(ctx.url, proxyUrl);
+      for (const [key, value] of proxyUrl.searchParams.entries()) {
+        url.searchParams.append(key, value);
+      }
+      await utils.proxyRequest(ctx, url.href, req, res, {
+        injectLiveReload: this._project.liveReload,
+        headHtml: this._project.headHtml,
+        indexer: this._project.indexer,
+        cacheDirectory: this._project.cacheDirectory,
+        file404html: this._project.file404html,
+      });
+    } catch (err) {
+      log.error(`Failed to proxy AEM request ${ctx.path}: ${err.message}`);
+      res.status(502).send(`Failed to proxy AEM request: ${err.message}`);
+    }
+
+    this.emit('request', req, res, ctx);
+  }
+
+  async setupApp() {
+    await super.setupApp();
+    if (this._enableLiveReload) {
+      this._liveReload = new LiveReload(this.log);
+      await this._liveReload.init(this.app, this._server);
+    }
+    const handler = asyncHandler(this.handleProxyModeRequest.bind(this));
+    this.app.get('*', handler);
+    this.app.post('*', handler);
+  }
+
+  async doStop() {
+    await super.stop();
+    if (this._liveReload) {
+      await this._liveReload.stop();
+      delete this._liveReload;
+    }
+  }
+}

package/src/server/Indexer.js

@@ -0,0 +1,152 @@
+/*
+ * Copyright 2021 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+import { resolve } from 'path';
+import { IndexConfig } from '@adobe/helix-shared-config';
+import { indexResource, contains } from '@adobe/helix-shared-indexer';
+import chalk from 'chalk-template';
+import chokidar from 'chokidar';
+
+export default class Indexer {
+  constructor() {
+    this._cwd = process.cwd();
+    this._logger = null;
+    this._last = {};
+    this._index = null;
+    this._printIndex = false;
+  }
+
+  withCwd(cwd) {
+    this._cwd = cwd;
+    return this;
+  }
+
+  withLogger(logger) {
+    this._logger = logger;
+    return this;
+  }
+
+  withPrintIndex(value) {
+    this._printIndex = value;
+    return this;
+  }
+
+  get log() {
+    return this._logger;
+  }
+
+  async init() {
+    await this.loadIndex();
+    // eslint-disable-next-line no-underscore-dangle
+    this._watcher = chokidar.watch([resolve(this._cwd, this._index._name)], {
+      persistent: true,
+      ignoreInitial: true,
+    });
+
+    this._watcher.on('all', async () => {
+      await this.loadIndex();
+      await this.onIndexChanged();
+    });
+    return this;
+  }
+
+  async close() {
+    if (this._watcher) {
+      await this._watcher.close();
+      delete this._watcher;
+    }
+  }
+
+  async loadIndex() {
+    const { log } = this;
+    try {
+      this._index = await new IndexConfig()
+        .withDirectory(this._cwd)
+        .withLogger(log)
+        .init();
+    } catch (e) {
+      log.error(`Error in helix-query.yaml: ${e.message}`);
+    }
+    if (this._printIndex && this._index.indices.length === 0) {
+      log.warn(chalk`AEM CLI started with {gray --print-index} but no valid {gray helix-query.yaml} found.`);
+    }
+  }
+
+  async onData(url, response) {
+    const { pathname } = new URL(url);
+    this._last = {
+      pathname,
+      response,
+    };
+    if (this._printIndex) {
+      await this.dump();
+    }
+  }
+
+  async onIndexChanged() {
+    await this.loadIndex();
+    if (this._printIndex) {
+      await this.dump();
+    }
+  }
+
+  async dump() {
+    const { log } = this;
+    const {
+      pathname,
+      response,
+    } = this._last;
+    if (!pathname) {
+      log.debug('No last path recorded, dump skipped.');
+      return;
+    }
+    const records = await this.getRecords(pathname, response);
+    if (records) {
+      if (records.length) {
+        log.info(chalk`Index information for {blue ${pathname}}`);
+      } else {
+        log.info(chalk`No index information matches {blue ${pathname}}`);
+      }
+      for (const idx of records) {
+        log.info(chalk`Index: {yellow ${idx.name}}`);
+        const pad = Object.keys(idx.properties).reduce((p, c) => Math.max(p, c.length), 0);
+        Object.entries(idx.properties).forEach(([key, value]) => {
+          if (typeof value === 'number') {
+            // eslint-disable-next-line no-param-reassign
+            value = chalk`{yellow ${value}}`;
+          } else {
+            // eslint-disable-next-line no-param-reassign
+            value = JSON.stringify(value);
+          }
+          log.info(chalk`  {gray ${key.padStart(pad)}}: ${value}`);
+        });
+      }
+    }
+  }
+
+  async getRecords(pathname, response) {
+    if (!this._index) {
+      return null;
+    }
+    return this._index.indices
+      .map((config) => {
+        if (contains(config, pathname)) {
+          return {
+            name: config.name,
+            properties: indexResource(pathname, response, config, this.log),
+          };
+        } else {
+          return null;
+        }
+      })
+      .filter((r) => !!r);
+  }
+}