@nordcraft/ssr 1.0.97 → 2.0.1

package/src/rendering/head.ts

@@ -8,7 +8,7 @@ import { CUSTOM_PROPERTIES_STYLESHEET_ID } from '@nordcraft/core/dist/styling/th
 import { easySort } from '@nordcraft/core/dist/utils/collections'
 import { VOID_HTML_ELEMENTS } from '@nordcraft/core/dist/utils/html'
 import { validateUrl } from '@nordcraft/core/dist/utils/url'
-import { isDefined } from '@nordcraft/core/dist/utils/util'
+import { isDefined, toBoolean } from '@nordcraft/core/dist/utils/util'
 import { escapeAttrValue } from '../rendering/attributes'
 import type { ProjectFiles, ToddleProject } from '../ssr.types'
 import { isCloudflareImagePath } from '../utils/media'
@@ -277,44 +277,51 @@ export const getHeadItems = ({
       Object.entries(pageInfo.meta),
       // Sort by index if it exists
       ([_, meta]) => meta.index ?? Infinity,
-    ).forEach(([id, metaEntry]) => {
-      if (Object.values(HeadTagTypes).includes(metaEntry.tag)) {
-        // If the tag has a name or property attribute, we use that as the key
-        // to avoid duplicates and to ensure sorting of tags later
-        const key = Object.entries(metaEntry.attrs ?? {}).find(
-          ([key]) => key === 'name' || key === 'property',
-        )
-        const headItemKey: HeadItemType = `${metaEntry.tag}:${
-          isDefined(key) ? applyFormula(key[1], context) : (id ?? nanoid())
-        }`
-        headItems.set(
-          headItemKey,
-          // Add the id to the tag so it's easier to dynamically update it later
-          // from our runtime (main.ts)
-          `<${metaEntry.tag} data-toddle-id="${id}" ${Object.entries(
-            metaEntry.attrs ?? {},
+    )
+      .filter(
+        ([_, meta]) =>
+          // Only include enabled meta tags
+          !isDefined(meta.enabled) ||
+          toBoolean(applyFormula(meta.enabled, context)),
+      )
+      .forEach(([id, metaEntry]) => {
+        if (Object.values(HeadTagTypes).includes(metaEntry.tag)) {
+          // If the tag has a name or property attribute, we use that as the key
+          // to avoid duplicates and to ensure sorting of tags later
+          const key = Object.entries(metaEntry.attrs ?? {}).find(
+            ([key]) => key === 'name' || key === 'property',
           )
-            .map(([key, formula]) => {
-              const value = applyFormula(formula, context)
-              if (value === true) {
-                // If the value is true, we just return the key - this is useful
-                // for tags like <script async> where async doesn't have a value
-                return key
-              }
-              return `${key}="${escapeAttrValue(value)}"`
-            })
-            .join(' ')} ${
-            VOID_HTML_ELEMENTS.includes(metaEntry.tag)
-              ? `/>`
-              : `>${
-                  metaEntry.content
-                    ? applyFormula(metaEntry.content, context)
-                    : ''
-                }</${metaEntry.tag}>`
-          }`,
-        )
-      }
-    })
+          const headItemKey: HeadItemType = `${metaEntry.tag}:${
+            isDefined(key) ? applyFormula(key[1], context) : (id ?? nanoid())
+          }`
+          headItems.set(
+            headItemKey,
+            // Add the id to the tag so it's easier to dynamically update it later
+            // from our runtime (main.ts)
+            `<${metaEntry.tag} data-toddle-id="${id}" ${Object.entries(
+              metaEntry.attrs ?? {},
+            )
+              .map(([key, formula]) => {
+                const value = applyFormula(formula, context)
+                if (value === true) {
+                  // If the value is true, we just return the key - this is useful
+                  // for tags like <script async> where async doesn't have a value
+                  return key
+                }
+                return `${key}="${escapeAttrValue(value)}"`
+              })
+              .join(' ')} ${
+              VOID_HTML_ELEMENTS.includes(metaEntry.tag)
+                ? `/>`
+                : `>${
+                    metaEntry.content
+                      ? applyFormula(metaEntry.content, context)
+                      : ''
+                  }</${metaEntry.tag}>`
+            }`,
+          )
+        }
+      })
   }
   return headItems
 }

package/src/rendering/testData.test.ts

@@ -241,7 +241,7 @@ describe('removeTestData', () => {
             inputs: {},
           },
         },
-      }).apis['a'],
+      }).apis?.['a'],
     ).toEqual({
       name: 'foo',
       url: valueFormula('https://example.com'),

package/src/routing/routing.test.ts

@@ -1,9 +1,13 @@
 import type { PageComponent } from '@nordcraft/core/dist/component/component.types'
 import { valueFormula } from '@nordcraft/core/dist/formula/formulaUtils'
 import { describe, expect, test } from 'bun:test'
-import { serverEnv } from '../rendering/formulaContext'
+import { getServerToddleObject, serverEnv } from '../rendering/formulaContext'
 import type { Route } from '../ssr.types'
-import { matchPageForUrl, matchRouteForUrl } from './routing'
+import {
+  getRouteDestination,
+  matchPageForUrl,
+  matchRouteForUrl,
+} from './routing'
 
 describe('matchPageForUrl', () => {
   test('it finds the correct page for a url', () => {
@@ -206,7 +210,7 @@ describe('matchRouteForUrl', () => {
           getFormula: () => undefined,
           getCustomFormula: () => undefined,
         },
-      }),
+      }) as any,
     ).toEqual({ name: 'docsRedirect', route: routes['docsRedirect'] })
   })
   test('it ignores disabled routes', () => {
@@ -269,7 +273,164 @@ describe('matchRouteForUrl', () => {
           getFormula: () => undefined,
           getCustomFormula: () => undefined,
         },
-      }),
+      }) as any,
     ).toEqual({ name: 'docsRedirect', route: routes['docsRedirect'] })
   })
 })
+describe('getRouteDestination', () => {
+  const getEnv = (req: Request) =>
+    serverEnv({
+      branchName: 'main',
+      req,
+      logErrors: false,
+    })
+
+  test('it returns the destination for a rewrite route', () => {
+    const route: Route = {
+      type: 'rewrite',
+      source: { path: [{ type: 'static', name: 'search' }], query: {} },
+      destination: {
+        url: valueFormula('results'),
+      },
+    }
+    const req = new Request('http://localhost:3000/search')
+    const url = getRouteDestination({
+      serverContext: getServerToddleObject({}),
+      req,
+      route,
+      env: getEnv(req),
+    })
+    expect(url?.toString()).toEqual('http://localhost:3000/results')
+  })
+
+  test('it returns the destination for a redirect route', () => {
+    const route: Route = {
+      type: 'redirect',
+      source: { path: [{ type: 'static', name: 'old' }], query: {} },
+      destination: {
+        url: valueFormula('new'),
+      },
+    }
+    const req = new Request('http://localhost:3000/old')
+    const url = getRouteDestination({
+      serverContext: getServerToddleObject({}),
+      req,
+      route,
+      env: getEnv(req),
+    })
+    expect(url?.toString()).toEqual('http://localhost:3000/new')
+  })
+
+  test('it returns undefined if a redirect points to the same URL', () => {
+    const route: Route = {
+      type: 'redirect',
+      source: { path: [{ type: 'static', name: 'same' }], query: {} },
+      destination: {
+        url: valueFormula('same'),
+      },
+    }
+    const req = new Request('http://localhost:3000/same')
+    const url = getRouteDestination({
+      serverContext: getServerToddleObject({}),
+      req,
+      route,
+      env: getEnv(req),
+    })
+    expect(url).toBeUndefined()
+  })
+
+  test('it allows a rewrite to point to the same URL', () => {
+    const route: Route = {
+      type: 'rewrite',
+      source: { path: [{ type: 'static', name: 'same' }], query: {} },
+      destination: {
+        url: valueFormula('same'),
+      },
+    }
+    const req = new Request('http://localhost:3000/same')
+    const url = getRouteDestination({
+      serverContext: getServerToddleObject({}),
+      req,
+      route,
+      env: getEnv(req),
+    })
+    expect(url?.toString()).toEqual('http://localhost:3000/same')
+  })
+
+  test('it handles dynamic parameters in the destination', () => {
+    const route: Route = {
+      type: 'rewrite',
+      source: {
+        path: [
+          { type: 'static', name: 'user' },
+          { type: 'param', name: 'id', testValue: '123' },
+        ],
+        query: {},
+      },
+      destination: {
+        path: {
+          profile: {
+            index: 0,
+            formula: valueFormula('profile'),
+          },
+          id: {
+            index: 1,
+            formula: {
+              path: ['Route parameters', 'path', 'id'],
+              type: 'path',
+            },
+          },
+        },
+      },
+    }
+    const req = new Request('http://localhost:3000/user/456')
+    const url = getRouteDestination({
+      serverContext: getServerToddleObject({}),
+      req,
+      route,
+      env: getEnv(req),
+    })
+    expect(url?.toString()).toEqual('http://localhost:3000/profile/456')
+  })
+
+  test('it handles relative URLs in the destination', () => {
+    const route: Route = {
+      type: 'redirect',
+      source: { path: [{ type: 'static', name: 'old' }], query: {} },
+      destination: {
+        url: valueFormula('/new-relative'),
+      },
+    }
+    const req = new Request('http://localhost:3000/old')
+    const url = getRouteDestination({
+      serverContext: getServerToddleObject({}),
+      req,
+      route,
+      env: getEnv(req),
+    })
+    expect(url?.toString()).toEqual('http://localhost:3000/new-relative')
+  })
+
+  test('it handles query parameters in the destination', () => {
+    const route: Route = {
+      type: 'rewrite',
+      source: { path: [{ type: 'static', name: 'search' }], query: {} },
+      destination: {
+        url: valueFormula('results'),
+        queryParams: {
+          q: {
+            formula: valueFormula('toddle'),
+          },
+        },
+      },
+    }
+    const req = new Request('http://localhost:3000/search')
+    const url = getRouteDestination({
+      serverContext: getServerToddleObject({}),
+      req,
+      route,
+      env: getEnv(req),
+    })
+    expect(url?.toString()).toEqual('http://localhost:3000/results?q=toddle')
+  })
+})

package/src/routing/routing.ts

@@ -127,12 +127,7 @@ export const getRouteDestination = ({
       serverContext,
     })
 
-    const url = getUrl(
-      route.destination,
-      formulaContext,
-      // Redirects can redirect to relative URLs - rewrites can't
-      route.type === 'redirect' ? requestUrl.origin : undefined,
-    )
+    const url = getUrl(route.destination, formulaContext, requestUrl.origin)
     if (
       route.type === 'redirect' &&
       requestUrl.origin === url.origin &&
@@ -141,11 +136,6 @@ export const getRouteDestination = ({
       // Redirects are not allowed to redirect to the same URL as their source
       return
     }
-    if (route.type === 'rewrite' && requestUrl.origin === url.origin) {
-      // Rewrites are not allowed from the same origin as the source
-      // This prevents potential recursive fetch calls from the server to itself
-      return
-    }
     return url
     // eslint-disable-next-line no-empty
   } catch {}

package/src/utils/media.test.ts

@@ -67,7 +67,7 @@ describe('transformRelativePaths()', () => {
           },
         },
       },
-    })
+    } as any)
   })
   test('it keeps absolute urls', () => {
     expect(
@@ -96,7 +96,7 @@ describe('transformRelativePaths()', () => {
           },
         },
       },
-    })
+    } as any)
   })
   test('it does not transform non-src attributes', () => {
     expect(
@@ -125,6 +125,6 @@ describe('transformRelativePaths()', () => {
           },
         },
       },
-    })
+    } as any)
   })
 })