@builder.io/sdk-svelte 0.6.4 → 0.7.1-0

package/src/functions/evaluate/node-runtime/node-runtime.ts

@@ -0,0 +1,138 @@
+import type { FunctionArguments, ExecutorArgs, BuilderGlobals } from '../helpers.js';
+import { getFunctionArguments } from '../helpers.js';
+import { safeDynamicRequire } from './safeDynamicRequire.js';
+import { fastClone } from '../../fast-clone.js';
+import { set } from '../../set.js';
+const ivm: typeof import('isolated-vm') = safeDynamicRequire('isolated-vm');
+const getSyncValName = (key: string) => `bldr_${key}_sync`;
+const BUILDER_SET_STATE_NAME = 'BUILDER_SET_STATE';
+const INJECTED_IVM_GLOBAL = 'BUILDER_IVM';
+
+// Convert all argument references to proxies, and pass `copySync` method to target object, to return a copy of the original JS object
+// https://github.com/laverdet/isolated-vm#referencecopysync
+const REF_TO_PROXY_FN = `
+var refToProxy = (obj) => {
+  if (typeof obj !== 'object' || obj === null) {
+    return obj;
+  }
+  return new Proxy({}, {
+    get(target, key) {
+        if (key === 'copySync') {
+          return () => obj.copySync();
+        }
+        const val = obj.getSync(key);
+        if (typeof val?.getSync === 'function') {
+            return refToProxy(val);
+        }
+        return val;
+    },
+    set(target, key, value) {
+        const v = typeof value === 'object' ? new ${INJECTED_IVM_GLOBAL}.Reference(value) : value;
+        obj.setSync(key, v);
+        ${BUILDER_SET_STATE_NAME}(key, value)
+    },
+    deleteProperty(target, key) {
+        obj.deleteSync(key);
+    }
+  })
+}
+`;
+const processCode = ({
+  code,
+  args
+}: {
+  code: string;
+  args: FunctionArguments;
+}) => {
+  const fnArgs = args.map(([name]) => `var ${name} = refToProxy(${getSyncValName(name)}); `).join('');
+
+  // the output is stringified and parsed back to the parent isolate if needed (when it's an `object`)
+  return `
+${REF_TO_PROXY_FN}
+${fnArgs}
+function theFunction() {
+  ${code}
+}
+
+let output = theFunction()
+
+if (typeof output === 'object' && output !== null) {
+  output = JSON.stringify(output.copySync ? output.copySync() : output);
+}
+
+output;
+`;
+};
+const getIsolateContext = () => {
+  // if (Builder.serverContext) {
+  //   return Builder.serverContext;
+  // }
+  // Builder.setServerContext(isolate.createContextSync());
+  const isolate = new ivm.Isolate({
+    memoryLimit: 128
+  });
+  return isolate.createContextSync();
+};
+export const runInNode = ({
+  code,
+  builder,
+  context,
+  event,
+  localState,
+  rootSetState,
+  rootState
+}: ExecutorArgs) => {
+  const state = fastClone({
+    ...rootState,
+    ...localState
+  });
+  const args = getFunctionArguments({
+    builder,
+    context,
+    event,
+    state
+  });
+  const isolateContext = getIsolateContext();
+  const jail = isolateContext.global;
+  // This makes the global object available in the context as `global`. We use `derefInto()` here
+  // because otherwise `global` would actually be a Reference{} object in the new isolate.
+  jail.setSync('global', jail.derefInto());
+
+  // We will create a basic `log` function for the new isolate to use.
+  jail.setSync('log', function (...logArgs: any[]) {
+    console.log(...logArgs);
+  });
+
+  /**
+   * Propagate state changes back to the reactive root state.
+   */
+  jail.setSync(BUILDER_SET_STATE_NAME, function (key: string, value: any) {
+    // mutate the `rootState` object itself. Important for cases where we do not have `rootSetState`
+    // like Qwik.
+    set(rootState, key, value);
+    // call the `rootSetState` function if it exists
+    rootSetState?.(rootState);
+  });
+  args.forEach(([key, arg]) => {
+    const val = typeof arg === 'object' ? new ivm.Reference(
+    // workaround: methods with default values for arguments is not being cloned over
+    key === 'builder' ? {
+      ...arg,
+      getUserAttributes: () => (arg as BuilderGlobals).getUserAttributes()
+    } : arg) : null;
+    jail.setSync(getSyncValName(key), val);
+  });
+  jail.setSync(INJECTED_IVM_GLOBAL, ivm);
+  const evalStr = processCode({
+    code,
+    args
+  });
+  const resultStr = isolateContext.evalSync(evalStr);
+  try {
+    // returning objects throw errors in isolated vm, so we stringify it and parse it back
+    const res = JSON.parse(resultStr);
+    return res;
+  } catch (_error: any) {
+    return resultStr;
+  }
+}

package/src/functions/evaluate/node-runtime/safeDynamicRequire.ts

@@ -0,0 +1,18 @@
+const noop = () => null;
+
+/**
+ * Allows us to require node-specific code safely within bundlers.
+ *
+ * https://github.com/laverdet/isolated-vm/issues/423
+ *
+ * NOTE: this code should only ever run in `node`, and never in an `edge` runtime.
+ * This is guaranteed by the fact that each SDK has separate bundles for each runtime.
+ * However, it might still end up running in the `browser` if the `node` bundle is loaded in the
+ * browser (which happens in many apps' dev mode, and certain other scenarios like Qwik's prod mode).
+ */
+export let safeDynamicRequire: typeof require = ((noop as unknown) as typeof require);
+try {
+  safeDynamicRequire = eval('require');
+} catch (error) {
+  /* empty */
+}

package/src/functions/get-content/generate-content-url.ts

@@ -2,18 +2,28 @@ import { flatten } from '../../helpers/flatten.js';
 import { getBuilderSearchParamsFromWindow, normalizeSearchParams } from '../get-builder-search-params/index.js';
 import type { GetContentOptions } from './types.js';
 import { DEFAULT_API_VERSION } from '../../types/api-version.js';
+const isPositiveNumber = (thing: unknown) => typeof thing === 'number' && !isNaN(thing) && thing >= 0;
 export const generateContentUrl = (options: GetContentOptions): URL => {
+  let {
+    noTraverse = false
+  } = options;
   const {
     limit = 30,
     userAttributes,
     query,
-    noTraverse = false,
     model,
     apiKey,
     includeRefs = true,
     enrich,
     locale,
-    apiVersion = DEFAULT_API_VERSION
+    apiVersion = DEFAULT_API_VERSION,
+    fields,
+    omit,
+    offset,
+    cacheSeconds,
+    staleCacheSeconds,
+    sort,
+    includeUnpublished
   } = options;
   if (!apiKey) {
     throw new Error('Missing API key');
@@ -21,7 +31,39 @@ export const generateContentUrl = (options: GetContentOptions): URL => {
   if (!['v2', 'v3'].includes(apiVersion)) {
     throw new Error(`Invalid apiVersion: expected 'v2' or 'v3', received '${apiVersion}'`);
   }
+
+  // Set noTraverse=true if NOT already passed by user, for query performance
+  if ((options.limit === undefined || options.limit > 1) && !('noTraverse' in options)) {
+    noTraverse = true;
+  }
   const url = new URL(`https://cdn.builder.io/api/${apiVersion}/content/${model}?apiKey=${apiKey}&limit=${limit}&noTraverse=${noTraverse}&includeRefs=${includeRefs}${locale ? `&locale=${locale}` : ''}${enrich ? `&enrich=${enrich}` : ''}`);
+  url.searchParams.set('omit', omit || 'meta.componentsUsed');
+  if (fields) {
+    url.searchParams.set('fields', fields);
+  }
+  if (Number.isFinite(offset) && offset! > -1) {
+    url.searchParams.set('offset', String(Math.floor(offset!)));
+  }
+  if (typeof includeUnpublished === 'boolean') {
+    url.searchParams.set('includeUnpublished', String(includeUnpublished));
+  }
+  if (cacheSeconds && isPositiveNumber(cacheSeconds)) {
+    url.searchParams.set('cacheSeconds', String(cacheSeconds));
+  }
+  if (staleCacheSeconds && isPositiveNumber(staleCacheSeconds)) {
+    url.searchParams.set('staleCacheSeconds', String(staleCacheSeconds));
+  }
+  if (sort) {
+    const flattened = flatten({
+      sort
+    });
+    for (const key in flattened) {
+      url.searchParams.set(key, JSON.stringify((flattened as any)[key]));
+    }
+  }
+
+  // TODO: how to express 'offset' in the url - as direct queryparam or as flattened in options[key] ?
+
   const queryOptions = {
     ...getBuilderSearchParamsFromWindow(),
     ...normalizeSearchParams(options.options || {})

package/src/functions/get-content/types.ts

@@ -8,12 +8,44 @@ export interface GetContentOptions {
   /** Number of items to fetch. Default is 1 */
   limit?: number;
 
-  /** User attributes to target on, such as { urlPath: '/foo', device: 'mobile', ...etc } */
+  /**
+   * Use to specify an offset for pagination of results. The default is 0.
+   */
+  offset?: number;
+
+  /**
+   * User attribute key value pairs to be used for targeting
+   * https://www.builder.io/c/docs/custom-targeting-attributes
+   *
+   * e.g.
+   * ```js
+   * userAttributes: {
+   *   urlPath: '/',
+   *   returnVisitor: true,
+   *   device: 'mobile'
+   * }
+   * ```
+   */
   userAttributes?: (Record<string, string> & {
     urlPath?: string;
   }) | null;
 
-  /** Custom query */
+  /**
+   * Mongodb style query of your data. E.g.:
+   *
+   * ```js
+   * query: {
+   *  id: 'abc123',
+   *  data: {
+   *    myCustomField: { $gt: 20 },
+   *  }
+   * }
+   * ```
+   *
+   * See more info on MongoDB's query operators and format.
+   *
+   * @see {@link https://docs.mongodb.com/manual/reference/operator/query/}
+   */
   query?: Record<string, any>;
 
   /**
@@ -38,7 +70,7 @@ export interface GetContentOptions {
   canTrack?: boolean;
 
   /**
-   * Include references in the response. Defaults to `true`.
+   * Include content of references in the response. Defaults to `true`.
    * @deprecated use `enrich` instead
    */
   includeRefs?: boolean;
@@ -59,4 +91,70 @@ export interface GetContentOptions {
    * Defaults to `v3`.
    */
   apiVersion?: 'v2' | 'v3';
+
+  /**
+   * Only include these fields.
+   * Note: 'omit' takes precedence over 'fields'
+   *
+   * @example
+   * ```
+   * fields: 'id, name, data.customField'
+   * ```
+   */
+  fields?: string;
+
+  /**
+   * Omit only these fields.
+   * Note: 'omit' takes precedence over 'fields'
+   *
+   * @example
+   * ```
+   * omit: 'data.bigField,data.blocks'
+   * ```
+   */
+  omit?: string;
+
+  /**
+   * Seconds to cache content. Sets the max-age of the cache-control header
+   * response header.
+   *
+   * Use a higher value for better performance, lower for content that will change more frequently
+   *
+   * @see {@link https://www.builder.io/c/docs/query-api#__next:~:text=%26includeRefs%3Dtrue-,cacheSeconds,-No}
+   */
+  cacheSeconds?: number;
+
+  /**
+   * Builder.io uses stale-while-revalidate caching at the CDN level. This means we always serve
+   * from edge cache and update caches in the background for maximum possible performance. This also
+   * means that the more frequently content is requested, the more fresh it will be. The longest we
+   * will ever hold something in stale cache is 1 day by default, and you can set this to be shorter
+   * yourself as well. We suggest keeping this high unless you have content that must change rapidly
+   * and gets very little traffic.
+   *
+   * @see {@link https://www.fastly.com/blog/prevent-application-network-instability-serve-stale-content}
+   */
+  staleCacheSeconds?: number;
+
+  /**
+   * Property to order results by.
+   * Use 1 for ascending and -1 for descending.
+   *
+   * The key is what you're sorting on, so the following example sorts by createdDate
+   * and because the value is 1, the sort is ascending.
+   *
+   * @example
+   * ```
+   * createdDate: 1
+   * ```
+   */
+  sort?: {
+    [key: string]: 1 | -1;
+  };
+
+  /**
+   * Include content entries in a response that are still in
+   * draft mode and un-archived. Default is false.
+   */
+  includeUnpublished?: boolean;
 }

package/src/functions/is-edge-runtime.ts

@@ -1,9 +1,9 @@
 import { isBrowser } from './is-browser.js';
+import { isNodeRuntime } from './is-node-runtime.js';
 
 /**
  * Identifies edge runtimes (edge, workers, serverless, etc.)
  */
 export function isEdgeRuntime(): boolean {
-  const hasNode = () => typeof process !== 'undefined' && process?.versions?.node;
-  return !isBrowser() && !hasNode();
+  return !isBrowser() && !isNodeRuntime();
 }

package/src/functions/is-node-runtime.ts

@@ -0,0 +1,8 @@
+import { checkIsDefined } from '../helpers/nullable';
+
+/**
+ * Identifies node runtime
+ */
+export function isNodeRuntime(): boolean {
+  return typeof process !== 'undefined' && checkIsDefined(process?.versions?.node);
+}