@static-suite/static-suite-data-server 0.0.1

package/src/lib/store/include/includeParser.types.ts

@@ -0,0 +1,99 @@
+import { Json } from '@lib/utils/object/object.types';
+
+/**
+ * Global parser that is able to parse static and dynamic includes.
+ */
+export type IncludeParser = {
+  /**
+   * Parse all static includes (entity, config, locale and custom).
+   *
+   * @param relativeFilepath - Relative file path, inside dataDir, to the file to be parsed.
+   * @param host - Object that will host a pointer to a target.
+   */
+  static(relativeFilepath: string, host: Json): void;
+
+  /**
+   * Parse all dynamic includes (queryInclude at this moment)
+   *
+   * @param host - Object that will host a pointer to a target.
+   */
+  dynamic(host: Json): void;
+};
+
+/**
+ * Option to be passed a generic include parser (except entity and query includes).
+ */
+export type GenericIncludeParserOptions = {
+  /**
+   * Object that will host a pointer to a target.
+   */
+  host: Json;
+
+  /**
+   * Target that will be referenced from a host.
+   *
+   * @remarks
+   * It can be any kind of data (object, string, array, int, etc), so we can not
+   * assume this is going to be an object.
+   *
+   * For example, custom includes can point to a string file, or query includes
+   * can return an error as a string.
+   *
+   * The only include that can ensure that its target is an object is entity include.
+   */
+  target: unknown;
+
+  /**
+   * Array of items to the mount point inside the host object, minus the last item (e.g.- ['data', 'content']).
+   */
+  mountPath: string[];
+
+  /**
+   * Last item of the mount point, that defines the key used to specify the include  (e.g.- "configInclude").
+   */
+  includeKey: string;
+};
+
+/**
+ * Option to be passed an entity include parser.
+ */
+export type EntityIncludeParserOptions = {
+  /**
+   * Object that will host a pointer to a target.
+   */
+  host: Json;
+
+  /**
+   * Entity object that will be referenced from a host.
+   *
+   * @remarks
+   * Since entity includes work only with entity data, we are
+   * sure that this is an object.
+   */
+  target: Json;
+
+  /**
+   * Array of items to the mount point inside the host object, minus the last item (e.g.- ['data', 'content']).
+   */
+  mountPath: string[];
+
+  /**
+   * Last item of the mount point, that defines the key used to specify the include  (e.g.- "configInclude").
+   */
+  includeKey: string;
+};
+
+/**
+ * Option to be passed a query include parser.
+ */
+export type QueryIncludeParserOptions = {
+  /**
+   * Object that will host a pointer to a target.
+   */
+  host: Json;
+
+  /**
+   * Full string of items to the mount point inside the host object.
+   */
+  includePath: string;
+};

package/src/lib/store/include/index.ts

@@ -0,0 +1 @@
+export * from './includeParser';

package/src/lib/store/include/parsers/__tests__/entityIncludeParser.test.ts

@@ -0,0 +1,43 @@
+import { entityIncludeParser } from '../entityIncludeParser';
+
+describe('entityIncludeParser', () => {
+  it('mounts data on correct path', () => {
+    const host = {
+      data: {
+        content: {
+          entity: {
+            entityInclude: 'xxx',
+          },
+        },
+      },
+    };
+    entityIncludeParser({
+      host,
+      target: { data: { content: { includedData: 'yyy' } } },
+      mountPath: ['data', 'content', 'entity'],
+      includeKey: 'entityInclude',
+    });
+    expect(host.data.content.entity).toStrictEqual({
+      includedData: 'yyy',
+    });
+  });
+
+  it('returns undefined when includeData has not data.content structure', () => {
+    const host = {
+      data: {
+        content: {
+          entity: {
+            entityInclude: 'xxx',
+          },
+        },
+      },
+    };
+    entityIncludeParser({
+      host,
+      target: { includedData: 'yyy' },
+      mountPath: ['data', 'content', 'entity'],
+      includeKey: 'entityInclude',
+    });
+    expect(host.data.content.entity).toBeUndefined();
+  });
+});

package/src/lib/store/include/parsers/configIncludeParser.ts

@@ -0,0 +1,8 @@
+import { GenericIncludeParserOptions } from '../includeParser.types';
+import { aliasIncludeParser } from './types/aliasIncludeParser';
+
+export const configIncludeParser = (
+  options: GenericIncludeParserOptions,
+): void => {
+  aliasIncludeParser(options);
+};

package/src/lib/store/include/parsers/customIncludeParser.ts

@@ -0,0 +1,8 @@
+import { GenericIncludeParserOptions } from '../includeParser.types';
+import { aliasWithoutTypeIncludeParser } from './types/aliasWithoutTypeIncludeParser';
+
+export const customIncludeParser = (
+  options: GenericIncludeParserOptions,
+): void => {
+  aliasWithoutTypeIncludeParser(options, 'custom');
+};

package/src/lib/store/include/parsers/entityIncludeParser.ts

@@ -0,0 +1,15 @@
+import { getObjValue } from '@lib/utils/object';
+import { EntityIncludeParserOptions } from '../includeParser.types';
+
+export const entityIncludeParser = ({
+  host,
+  target,
+  mountPath,
+}: EntityIncludeParserOptions): void => {
+  // Remove a level from mountPath, to mount entity a level up.
+  const includeKey = mountPath.pop();
+  if (includeKey) {
+    const mountPoint = getObjValue(host, mountPath);
+    mountPoint[includeKey] = target?.data?.content;
+  }
+};

package/src/lib/store/include/parsers/index.ts

@@ -0,0 +1,5 @@
+export * from './configIncludeParser';
+export * from './customIncludeParser';
+export * from './entityIncludeParser';
+export * from './localeIncludeParser';
+export * from './queryIncludeParser';

package/src/lib/store/include/parsers/localeIncludeParser.ts

@@ -0,0 +1,8 @@
+import { GenericIncludeParserOptions } from '../includeParser.types';
+import { aliasIncludeParser } from './types/aliasIncludeParser';
+
+export const localeIncludeParser = (
+  options: GenericIncludeParserOptions,
+): void => {
+  aliasIncludeParser(options);
+};

package/src/lib/store/include/parsers/queryIncludeParser.ts

@@ -0,0 +1,51 @@
+import { config } from '@lib/config';
+import { RunMode } from '@lib/dataServer.types';
+import { queryRunner } from '@lib/query';
+import { isQueryErrorResponse } from '@lib/query/query.types';
+import { getObjValue } from '@lib/utils/object';
+import { QueryIncludeParserOptions } from '../includeParser.types';
+import { aliasWithoutTypeIncludeParser } from './types/aliasWithoutTypeIncludeParser';
+
+/**
+ * Parses query includes.
+ *
+ * @remarks
+ * Instead of executing a query and adding its result to a JSON file,
+ * create a Proxy so queries are only executed when they are consumed,
+ * in a Just-In-Time way.
+ */
+export const queryIncludeParser = ({
+  host,
+  includePath,
+}: QueryIncludeParserOptions): void => {
+  const queryDefinition = getObjValue(host, includePath);
+  if (!queryDefinition) {
+    return;
+  }
+
+  // Execute the query when the "data" property is accessed.
+  const proxyHandler = {
+    get: (target: any, prop: string) => {
+      if (prop === 'data') {
+        const queryResponse = queryRunner.run(queryDefinition);
+        if (isQueryErrorResponse(queryResponse)) {
+          return config.runMode === RunMode.DEV
+            ? `${queryResponse.error} (message visible only in run mode DEV)`
+            : null;
+        }
+        return queryResponse.data;
+      }
+      return undefined;
+    },
+  };
+  const target = new Proxy({ data: null }, proxyHandler);
+
+  const mountPath = includePath.split('.');
+  const includeKey = mountPath.pop();
+  if (includeKey) {
+    aliasWithoutTypeIncludeParser(
+      { host, target, mountPath, includeKey },
+      'query',
+    );
+  }
+};

package/src/lib/store/include/parsers/types/__tests__/aliasIncludeParser.test.ts

@@ -0,0 +1,37 @@
+import { aliasIncludeParser } from '../aliasIncludeParser';
+
+describe('aliasIncludeParser', () => {
+  it('mount data on correct paths without alias and deletes original path', () => {
+    const fileContent = {
+      data: {
+        localeInclude: 'xxx',
+      },
+    };
+    aliasIncludeParser({
+      host: fileContent,
+      target: { includedData: 'yyy' },
+      mountPath: ['data'],
+      includeKey: 'localeInclude',
+    });
+    expect(fileContent.data).toStrictEqual({
+      locale: { includedData: 'yyy' },
+    });
+  });
+
+  it('mount data on correct paths with alias and deletes original path', () => {
+    const fileContent = {
+      data: {
+        myLocaleInclude: 'xxx',
+      },
+    };
+    aliasIncludeParser({
+      host: fileContent,
+      target: { includedData: 'yyy' },
+      mountPath: ['data'],
+      includeKey: 'myLocaleInclude',
+    });
+    expect(fileContent.data).toStrictEqual({
+      myLocale: { includedData: 'yyy' },
+    });
+  });
+});

package/src/lib/store/include/parsers/types/__tests__/aliasWithoutTypeIncludeParser.test.ts

@@ -0,0 +1,43 @@
+import { aliasWithoutTypeIncludeParser } from '../aliasWithoutTypeIncludeParser';
+
+describe('aliasWithoutTypeIncludeParser', () => {
+  it('mount data on correct paths without alias and deletes original path', () => {
+    const hostObject = {
+      data: {
+        customInclude: 'xxx',
+      },
+    };
+    aliasWithoutTypeIncludeParser(
+      {
+        host: hostObject,
+        target: { includedData: 'yyy' },
+        mountPath: ['data'],
+        includeKey: 'customInclude',
+      },
+      'custom',
+    );
+    expect(hostObject.data).toStrictEqual({
+      custom: { includedData: 'yyy' },
+    });
+  });
+
+  it('mount data on correct paths with alias and deletes original path', () => {
+    const hostObject = {
+      data: {
+        myCustomInclude: 'xxx',
+      },
+    };
+    aliasWithoutTypeIncludeParser(
+      {
+        host: hostObject,
+        target: { includedData: 'yyy' },
+        mountPath: ['data'],
+        includeKey: 'myCustomInclude',
+      },
+      'custom',
+    );
+    expect(hostObject.data).toStrictEqual({
+      my: { includedData: 'yyy' },
+    });
+  });
+});

package/src/lib/store/include/parsers/types/aliasIncludeParser.ts

@@ -0,0 +1,13 @@
+import { GenericIncludeParserOptions } from '@lib/store/include/includeParser.types';
+import { getObjValue } from '@lib/utils/object';
+
+export const aliasIncludeParser = ({
+  host,
+  target,
+  mountPath,
+  includeKey,
+}: GenericIncludeParserOptions): void => {
+  const mountPoint = getObjValue(host, mountPath);
+  mountPoint[includeKey.replace('Include', '')] = target;
+  delete mountPoint[includeKey];
+};

package/src/lib/store/include/parsers/types/aliasWithoutTypeIncludeParser.ts

@@ -0,0 +1,22 @@
+import { GenericIncludeParserOptions } from '@lib/store/include/includeParser.types';
+import { getObjValue } from '@lib/utils/object';
+/**
+ *
+ * @param options - Object with options as defined in @see {@link IncludeParserOptions}
+ * @param type - Type of include (custom, query, etc)
+ */
+export const aliasWithoutTypeIncludeParser = (
+  { host, target, mountPath, includeKey }: GenericIncludeParserOptions,
+  type: string,
+): void => {
+  const mountPoint = getObjValue(host, mountPath);
+  const mountPointKey =
+    includeKey.replace('Include', '') === type
+      ? type
+      : includeKey.replace(
+          `${type.charAt(0).toUpperCase() + type.slice(1)}Include`,
+          '',
+        );
+  mountPoint[mountPointKey] = target;
+  delete mountPoint[includeKey];
+};

package/src/lib/store/index.ts

@@ -0,0 +1 @@
+export * from './store';

package/src/lib/store/store.ts

@@ -0,0 +1,105 @@
+import microtime from 'microtime';
+import { VARIANT_SEPARATOR } from '@lib/utils/string';
+import { logger } from '@lib/utils/logger';
+import { cache } from '@lib/utils/cache';
+import {
+  Store,
+  StoreData,
+  StoreSubset,
+  StoreSubsetOptions,
+} from './store.types';
+
+// Instantiate the subset cache so it can be accessed faster.
+const subsetCache = cache.bin<StoreSubset>('store-subset');
+
+const initIndex = () => {
+  return {
+    url: new Map<string, any>(),
+    uuid: new Map<string, any>(),
+    custom: new Map<string, any>(),
+  };
+};
+
+const initData = () => new Map<string, any>() as StoreData<string, any>;
+export const store: Store = {
+  syncDate: null,
+  data: initData(),
+  deleted: new Set<string>(),
+  index: initIndex(),
+};
+
+store.data.subset = (options: StoreSubsetOptions): StoreSubset => {
+  const startDate = microtime.now();
+
+  // Merge provided options with default ones.
+  const defaultOptions = {
+    variant: '_main',
+    ext: 'json',
+    recursive: 'true',
+  };
+  const opts = { ...defaultOptions, ...options };
+
+  let subset: StoreSubset = { filenames: [], items: [] };
+
+  const dirWithTrimmedSlashes = opts.dir?.replace(/^\//, '').replace(/\/$/, '');
+  const dirPart = dirWithTrimmedSlashes ? `${dirWithTrimmedSlashes}/` : '';
+
+  let variantPart;
+  if (opts.variant) {
+    const recursiveGroup = opts.recursive ? '.' : '[^/]';
+    variantPart =
+      opts.variant === '_main'
+        ? `((?!--)${recursiveGroup})+`
+        : `${recursiveGroup}+${VARIANT_SEPARATOR}${opts.variant}`;
+  } else {
+    variantPart = '';
+  }
+
+  let extensionPart;
+  if (opts.recursive) {
+    extensionPart = opts.ext ? `.${opts.ext}` : '.+';
+  } else {
+    extensionPart = opts.ext ? `.${opts.ext}` : '[^/]+';
+  }
+
+  const pattern = `^${dirPart}${variantPart}${extensionPart}$`;
+  logger.debug(`Store subset pattern: ${pattern}`);
+  const cachedSubset = subsetCache.get(pattern);
+  if (cachedSubset) {
+    subset = cachedSubset;
+    logger.debug(
+      `Store subset obtained from cache in ${
+        (microtime.now() - startDate) / 1000
+      }ms. ${subset.items.length} items.`,
+    );
+  } else {
+    const regex = new RegExp(pattern);
+    const mapKeys = Array.from(store.data.keys());
+    mapKeys.forEach(k => {
+      if (k.match(regex)) {
+        subset.filenames.push(k);
+        subset.items.push(store.data.get(k));
+      }
+    });
+    subsetCache.set(pattern, subset);
+    logger.debug(
+      `Store subset created in ${(microtime.now() - startDate) / 1000} ms. ${
+        subset.items.length
+      } items.`,
+    );
+  }
+
+  return subset;
+};
+
+/**
+ * Resets store and deletes all loaded data.
+ */
+export const resetStore = (): void => {
+  store.syncDate = null;
+  const previousSubset = store.data.subset;
+  store.data = initData();
+  store.data.subset = previousSubset;
+  store.deleted.clear();
+  store.index = initIndex();
+};