@lwrjs/static 0.12.0-alpha.3 → 0.12.0-alpha.30

package/build/cjs/providers/static-asset-provider.cjs

@@ -68,10 +68,8 @@ var StaticAssetProvider = class {
     const mime = metadata.mimeType || (0, import_shared_utils.mimeLookup)(siteAssetPath);
     const ext = import_path.default.extname(`x.${siteAssetPath}`).toLowerCase().substring(1);
     const type = this.assetsOnLambda ? "asset" : "external";
-    const content = this.assetsOnLambda ? function(encoding) {
+    const content = function(encoding) {
       return import_fs_extra.default.readFileSync(siteAssetPath, encoding);
-    } : () => {
-      throw Error(`[${this.name}] Asset is not on lambda ${siteAssetPath}`);
     };
     const uri = this.assetsOnLambda ? fileAssetPath : import_path.default.join(this.siteRootDir, fileAssetPath);
     import_diagnostics.logger.debug({label: `${this.name}`, message: `uri ${assetIdentifier.specifier} -> ${uri}`});

package/build/cjs/providers/static-bundle-provider.cjs

@@ -31,7 +31,6 @@ var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 var import_path = __toModule(require("path"));
 var import_fs_extra = __toModule(require("fs-extra"));
 var import_static_utils = __toModule(require("../utils/static-utils.cjs"));
-var LWR_SSR_BUNDLE_PREFIX = "@lwrjs/lwc-ssr/";
 var StaticBundleProvider = class {
   constructor(_config, context) {
     this.name = "static-bundle-provider";
@@ -54,17 +53,10 @@ var StaticBundleProvider = class {
     const siteBundles = debug && this.debugSiteBundles ? this.debugSiteBundles : this.siteBundles;
     const metadata = await (0, import_static_utils.getLocalizedBundle)(specifier, siteBundles, localeId, this.i18n);
     if (!metadata) {
-      if (!specifier.startsWith(LWR_SSR_BUNDLE_PREFIX)) {
-        import_diagnostics.logger.warn({
-          label: `${this.name}`,
-          message: `did not find requested specifier ${specifier}`
-        });
-      }
       return void 0;
     }
     const bundlePath = import_path.default.join(this.siteRootDir, metadata.path);
-    const skipDebugModeCode = debug && (0, import_shared_utils.getFeatureFlags)().SSR_STATIC_BUNDLES;
-    const code = skipDebugModeCode ? 'throw new Error("Unexpected code reference");' : (await import_fs_extra.default.readFile(bundlePath)).toString("utf-8");
+    const code = await this.getCode(bundlePath, debug, specifier, localeId);
     const imports = metadata.imports.map((specifier2) => {
       const importModule = (0, import_shared_utils.explodeSpecifier)(specifier2);
       if (!importModule.version) {
@@ -105,5 +97,30 @@ var StaticBundleProvider = class {
       src: bundlePath
     };
   }
+  async getCode(bundlePath, debug, specifier, localeId) {
+    const isLambda = process.env.AWS_LAMBDA_FUNCTION_NAME !== void 0;
+    let bundleSourcePath = bundlePath;
+    try {
+      if (debug && isLambda) {
+        const siteBundles = this.siteBundles;
+        const metadata = await (0, import_static_utils.getLocalizedBundle)(specifier, siteBundles, localeId, this.i18n);
+        if (!metadata) {
+          import_diagnostics.logger.warn({
+            label: "static-bundle-provider",
+            message: `Unexpected code reference: ${specifier}`
+          });
+          return `throw new Error('Unexpected code reference: ${specifier}');`;
+        }
+        bundleSourcePath = import_path.default.join(this.siteRootDir, metadata.path);
+      }
+      return (await import_fs_extra.default.readFile(bundleSourcePath)).toString("utf-8");
+    } catch (err) {
+      import_diagnostics.logger.warn({
+        label: "static-bundle-provider",
+        message: `Unexpected code reference: ${specifier} ${bundleSourcePath}`
+      }, err);
+      return `throw new Error('Unexpected code reference: ${specifier} ${bundleSourcePath}');`;
+    }
+  }
 };
 var static_bundle_provider_default = StaticBundleProvider;

package/build/cjs/providers/static-module-provider.cjs

@@ -60,7 +60,7 @@ var StaticModuleProvider = class {
     const localeId = runtimeParams?.locale || this.i18n.defaultLocale;
     const metadata = await (0, import_static_utils.getLocalizedBundle)(specifier, this.siteBundles, localeId, this.i18n);
     if (metadata) {
-      import_diagnostics.logger.info({
+      import_diagnostics.logger.debug({
         label: `${this.name}`,
         message: `Module Entry request for static bundle ${specifier}`
       });

package/build/cjs/providers/static-resource-provider.cjs

@@ -43,8 +43,9 @@ var StaticResourceProvider = class {
   }
   async getResource(resourceIdentity, runtimeEnvironment) {
     const {debug} = runtimeEnvironment;
-    const metadata = debug && this.debugSiteResources ? this.debugSiteResources.resources[resourceIdentity.specifier] : this.siteResources.resources[resourceIdentity.specifier];
-    if (!metadata) {
+    const metadata = this.siteResources.resources[resourceIdentity.specifier];
+    const debugMetadata = this.debugSiteResources ? this.debugSiteResources.resources[resourceIdentity.specifier] : void 0;
+    if (!metadata && !debugMetadata) {
       import_diagnostics.logger.warn({
         label: `${this.name}`,
         message: `Did not find requested specifier ${resourceIdentity.specifier}`
@@ -52,17 +53,24 @@ var StaticResourceProvider = class {
       return void 0;
     }
     const resourcePath = import_path.default.join(this.siteRootDir, metadata.path);
+    const debugResourcePath = debugMetadata ? import_path.default.join(this.siteRootDir, debugMetadata.path) : void 0;
+    const isLambda = process.env.AWS_LAMBDA_FUNCTION_NAME !== void 0;
+    const useDebug = debug && !isLambda && debugResourcePath;
     const type = metadata.mimeType || (0, import_shared_utils.mimeLookup)(resourcePath) || "application/javascript";
     return {
       type,
       stream: () => {
-        import_diagnostics.logger.info({
+        import_diagnostics.logger.debug({
           label: `${this.name}`,
           message: `Resource read from lambda ${resourceIdentity.specifier}`
         });
-        return import_fs_extra.default.createReadStream(resourcePath);
+        if (useDebug) {
+          return import_fs_extra.default.createReadStream(debugResourcePath);
+        } else {
+          return import_fs_extra.default.createReadStream(resourcePath);
+        }
       },
-      src: resourcePath,
+      src: useDebug ? debugResourcePath : resourcePath,
       inline: metadata.inline
     };
   }

package/build/cjs/site-metadata.cjs

@@ -64,6 +64,8 @@ var SiteMetadataImpl = class {
   }
   async persistSiteMetadata() {
     const siteMetadataPath = import_path.default.join(this.options.rootDir, SITE_METADATA_PATH);
+    if (siteMetadataPath.indexOf("__skip_directory_creation__") !== -1)
+      return;
     try {
       if (!import_fs_extra.default.existsSync(siteMetadataPath)) {
         await import_fs_extra.default.mkdir(siteMetadataPath, {recursive: true});

package/build/es/providers/static-asset-provider.js

@@ -48,13 +48,10 @@ export default class StaticAssetProvider {
         const ext = path.extname(`x.${siteAssetPath}`).toLowerCase().substring(1);
         // Unless assets on lambda feature flag is set indicate the asset source is external
         const type = this.assetsOnLambda ? 'asset' : 'external';
-        const content = this.assetsOnLambda
-            ? function (encoding) {
-                return fs.readFileSync(siteAssetPath, encoding);
-            }
-            : () => {
-                throw Error(`[${this.name}] Asset is not on lambda ${siteAssetPath}`);
-            };
+        const content = function (encoding) {
+            return fs.readFileSync(siteAssetPath, encoding);
+        };
+        // Create URI
         const uri = this.assetsOnLambda ? fileAssetPath : path.join(this.siteRootDir, fileAssetPath);
         logger.debug({ label: `${this.name}`, message: `uri ${assetIdentifier.specifier} -> ${uri}` });
         return {

package/build/es/providers/static-bundle-provider.d.ts

@@ -8,5 +8,15 @@ export default class StaticBundleProvider implements BundleProvider {
     i18n: import("@lwrjs/types").I18NConfig;
     constructor(_config: {}, context: ProviderContext);
     bundle<BundleIdentifier extends AbstractModuleId, RE extends RuntimeEnvironment>(moduleId: BundleIdentifier, runtimeEnvironment: RE, runtimeParams: RuntimeParams): Promise<BundleDefinition | undefined>;
+    /**
+     * Get the source code for the a static bundle
+     * If we are running in a lambda and the mode is debug we will return the prod source code instead of the debug source code
+     *
+     * @param bundlePath The default path for the bundle for prod read from .metadata/bundle-metadata.json, for debug .metadata/bundle-metadata-debug.json
+     * @param debug Is the request in debug mode?
+     * @param specifier Root specifier for the requested bundle
+     * @param localeId Locale id (e.g. en-US) for the current request
+     */
+    getCode(bundlePath: string, debug: boolean, specifier: string, localeId: string): Promise<string>;
 }
 //# sourceMappingURL=static-bundle-provider.d.ts.map

package/build/es/providers/static-bundle-provider.js

@@ -1,9 +1,8 @@
 import { logger } from '@lwrjs/diagnostics';
-import { explodeSpecifier, getSpecifier, getFeatureFlags } from '@lwrjs/shared-utils';
+import { explodeSpecifier, getSpecifier } from '@lwrjs/shared-utils';
 import path from 'path';
 import fs from 'fs-extra';
 import { getLocalizedBundle, resolveStaticBundleVersion } from '../utils/static-utils.js';
-const LWR_SSR_BUNDLE_PREFIX = '@lwrjs/lwc-ssr/';
 export default class StaticBundleProvider {
     constructor(_config, context) {
         this.name = 'static-bundle-provider';
@@ -23,22 +22,12 @@ export default class StaticBundleProvider {
         const siteBundles = debug && this.debugSiteBundles ? this.debugSiteBundles : this.siteBundles;
         const metadata = await getLocalizedBundle(specifier, siteBundles, localeId, this.i18n);
         if (!metadata) {
-            // ignore ssr module requests
-            if (!specifier.startsWith(LWR_SSR_BUNDLE_PREFIX)) {
-                logger.warn({
-                    label: `${this.name}`,
-                    message: `did not find requested specifier ${specifier}`,
-                });
-            }
             return undefined;
         }
-        // Have to make the bundle code available for SSR
+        // Default bundle source path
         const bundlePath = path.join(this.siteRootDir, metadata.path);
-        // workaround: debug bundles don't exist for SSR in this scenario since it's never actually used
-        const skipDebugModeCode = debug && getFeatureFlags().SSR_STATIC_BUNDLES;
-        const code = skipDebugModeCode
-            ? 'throw new Error("Unexpected code reference");'
-            : (await fs.readFile(bundlePath)).toString('utf-8');
+        // Get the associated bundle source code
+        const code = await this.getCode(bundlePath, debug, specifier, localeId);
         const imports = metadata.imports.map((specifier) => {
             const importModule = explodeSpecifier(specifier);
             if (!importModule.version) {
@@ -83,5 +72,50 @@ export default class StaticBundleProvider {
             src: bundlePath,
         };
     }
+    /**
+     * Get the source code for the a static bundle
+     * If we are running in a lambda and the mode is debug we will return the prod source code instead of the debug source code
+     *
+     * @param bundlePath The default path for the bundle for prod read from .metadata/bundle-metadata.json, for debug .metadata/bundle-metadata-debug.json
+     * @param debug Is the request in debug mode?
+     * @param specifier Root specifier for the requested bundle
+     * @param localeId Locale id (e.g. en-US) for the current request
+     */
+    async getCode(bundlePath, debug, specifier, localeId) {
+        // Flag is used to indicate that we are running on a lambda
+        const isLambda = process.env.AWS_LAMBDA_FUNCTION_NAME !== undefined;
+        // Default source code path determined from metadata based on debug mode
+        let bundleSourcePath = bundlePath;
+        try {
+            // This is the special case where the request is in debug mode and we are on the lambda
+            // So we will look up the prod source code instead of the debug source code
+            if (debug && isLambda) {
+                const siteBundles = this.siteBundles;
+                const metadata = await getLocalizedBundle(specifier, siteBundles, localeId, this.i18n);
+                if (!metadata) {
+                    // We did not find the bundle prod bundle even though we did find it in the debug metadata before
+                    logger.warn({
+                        label: 'static-bundle-provider',
+                        message: `Unexpected code reference: ${specifier}`,
+                    });
+                    // Returning source code that throws and error is someone tries to evaluate it
+                    return `throw new Error('Unexpected code reference: ${specifier}');`;
+                }
+                // Overwrite the default source code path the prod source code path
+                bundleSourcePath = path.join(this.siteRootDir, metadata.path);
+            }
+            // Read the bundle source code.
+            return (await fs.readFile(bundleSourcePath)).toString('utf-8');
+        }
+        catch (err) {
+            // Ran it an un-expected error reading the bundle source code
+            logger.warn({
+                label: 'static-bundle-provider',
+                message: `Unexpected code reference: ${specifier} ${bundleSourcePath}`,
+            }, err);
+            // Returning source code that throws and error is someone tries to evaluate it
+            return `throw new Error('Unexpected code reference: ${specifier} ${bundleSourcePath}');`;
+        }
+    }
 }
 //# sourceMappingURL=static-bundle-provider.js.map

package/build/es/providers/static-module-provider.js

@@ -36,7 +36,7 @@ export default class StaticModuleProvider {
         const localeId = (runtimeParams?.locale || this.i18n.defaultLocale);
         const metadata = await getLocalizedBundle(specifier, this.siteBundles, localeId, this.i18n);
         if (metadata) {
-            logger.info({
+            logger.debug({
                 label: `${this.name}`,
                 message: `Module Entry request for static bundle ${specifier}`,
             });

package/build/es/providers/static-resource-provider.js

@@ -15,10 +15,11 @@ export default class StaticResourceProvider {
     }
     async getResource(resourceIdentity, runtimeEnvironment) {
         const { debug } = runtimeEnvironment;
-        const metadata = debug && this.debugSiteResources
+        const metadata = this.siteResources.resources[resourceIdentity.specifier];
+        const debugMetadata = this.debugSiteResources
             ? this.debugSiteResources.resources[resourceIdentity.specifier]
-            : this.siteResources.resources[resourceIdentity.specifier];
-        if (!metadata) {
+            : undefined;
+        if (!metadata && !debugMetadata) {
             logger.warn({
                 label: `${this.name}`,
                 message: `Did not find requested specifier ${resourceIdentity.specifier}`,
@@ -26,19 +27,31 @@ export default class StaticResourceProvider {
             return undefined;
         }
         const resourcePath = path.join(this.siteRootDir, metadata.path);
+        const debugResourcePath = debugMetadata ? path.join(this.siteRootDir, debugMetadata.path) : undefined;
+        const isLambda = process.env.AWS_LAMBDA_FUNCTION_NAME !== undefined;
+        const useDebug = debug && !isLambda && debugResourcePath;
         // Figure out mime type
         const type = metadata.mimeType || mimeLookup(resourcePath) || 'application/javascript';
         return {
             type,
             // Have to make the loader shim code available for SSR
             stream: () => {
-                logger.info({
+                logger.debug({
                     label: `${this.name}`,
                     message: `Resource read from lambda ${resourceIdentity.specifier}`,
                 });
-                return fs.createReadStream(resourcePath);
+                if (useDebug) {
+                    // use the debug resource if:
+                    // - debug mode is ON
+                    // - isLambda is false
+                    // - the debug version of the resource exists
+                    return fs.createReadStream(debugResourcePath);
+                }
+                else {
+                    return fs.createReadStream(resourcePath);
+                }
             },
-            src: resourcePath,
+            src: useDebug ? debugResourcePath : resourcePath,
             inline: metadata.inline,
         };
     }

package/build/es/site-metadata.js

@@ -37,6 +37,8 @@ export class SiteMetadataImpl {
     async persistSiteMetadata() {
         // Create the metadata directory if if does not exist
         const siteMetadataPath = path.join(this.options.rootDir, SITE_METADATA_PATH);
+        if (siteMetadataPath.indexOf('__skip_directory_creation__') !== -1)
+            return;
         try {
             if (!fs.existsSync(siteMetadataPath)) {
                 await fs.mkdir(siteMetadataPath, { recursive: true });

package/package.json

@@ -4,7 +4,7 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.12.0-alpha.3",
+    "version": "0.12.0-alpha.30",
     "homepage": "https://developer.salesforce.com/docs/platform/lwr/overview",
     "repository": {
         "type": "git",
@@ -48,11 +48,11 @@
         "build/**/*.d.ts"
     ],
     "dependencies": {
-        "@lwrjs/diagnostics": "0.12.0-alpha.3",
-        "@lwrjs/shared-utils": "0.12.0-alpha.3"
+        "@lwrjs/diagnostics": "0.12.0-alpha.30",
+        "@lwrjs/shared-utils": "0.12.0-alpha.30"
     },
     "devDependencies": {
-        "@lwrjs/types": "0.12.0-alpha.3",
+        "@lwrjs/types": "0.12.0-alpha.30",
         "@types/express": "^4.17.21",
         "jest": "^26.6.3",
         "jest-express": "^1.12.0",
@@ -65,5 +65,5 @@
     "volta": {
         "extends": "../../../package.json"
     },
-    "gitHead": "48f97b40cbacce6cd6a6faee9206a465832c6774"
+    "gitHead": "5273cb7ece90a3a28645cb1dfde9d315548605db"
 }