@graphql-mesh/string-interpolation 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @graphql-mesh/string-interpolation
 
+## 0.2.0
+
+### Minor Changes
+
+- 974e703e2: No longer import entire lodash library but instead individual smaller packages
+
+### Patch Changes
+
+- 974e703e2: Cleanup dependencies
+- 974e703e2: Use deeper lodash imports to have better treeshaking and avoid using eval
+
 ## 0.1.0
 
 ### Minor Changes

package/dist/index.d.ts

@@ -1,2 +1,5 @@
 import { Interpolator } from './interpolator';
+export declare function hashObject(value: any): string;
 export { Interpolator };
+export declare const stringInterpolator: Interpolator;
+export * from './resolver-data-factory';

package/dist/index.js

@@ -4,8 +4,9 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
 
-const _ = _interopDefault(require('lodash'));
+const lodashGet = _interopDefault(require('lodash.get'));
 const JsonPointer = _interopDefault(require('json-pointer'));
+const dayjs = _interopDefault(require('dayjs'));
 
 const defaultOptions = {
     delimiter: ['{', '}'],
@@ -17,7 +18,8 @@ const lowercase = value => value.toLowerCase();
 
 const titlecase = value => value.replace(/\w\S*/g, s => s.charAt(0).toUpperCase() + s.substr(1).toLowerCase());
 
-const defaultModifiers = [{
+const defaultModifiers = [
+    {
         key: 'uppercase',
         transform: uppercase,
     },
@@ -28,7 +30,8 @@ const defaultModifiers = [{
     {
         key: 'title',
         transform: titlecase,
-    }];
+    },
+];
 
 class Interpolator {
     constructor(options = defaultOptions) {
@@ -68,20 +71,20 @@ class Interpolator {
         return matches ? this.extractRules(matches) : [];
     }
     extractRules(matches) {
-        return matches.map((match) => {
+        return matches.map(match => {
             const alternativeText = this.getAlternativeText(match);
             const modifiers = this.getModifiers(match);
             return {
                 key: this.getKeyFromMatch(match),
                 replace: match,
                 modifiers,
-                alternativeText
+                alternativeText,
             };
         });
     }
     getKeyFromMatch(match) {
         const removeReservedSymbols = [':', '|'];
-        return this.removeDelimiter(removeReservedSymbols.reduce((val, sym) => val.indexOf(sym) > 0 ? this.removeAfter(val, sym) : val, match));
+        return this.removeDelimiter(removeReservedSymbols.reduce((val, sym) => (val.indexOf(sym) > 0 ? this.removeAfter(val, sym) : val), match));
     }
     removeDelimiter(val) {
         return val.replace(new RegExp(this.delimiterStart(), 'g'), '').replace(new RegExp(this.delimiterEnd(), 'g'), '');
@@ -138,7 +141,7 @@ class Interpolator {
     }
     applyData(key, data) {
         const [prop, ptr] = key.split('#');
-        const propData = _.get(data, prop);
+        const propData = lodashGet(data, prop);
         if (ptr) {
             try {
                 return JsonPointer.get(propData, ptr);
@@ -158,7 +161,7 @@ class Interpolator {
     applyModifiers(modifiers, str, rawData) {
         try {
             const transformers = modifiers.map(modifier => modifier && modifier.transform);
-            return transformers.reduce((str, transform) => transform ? transform(str, rawData) : str, str);
+            return transformers.reduce((str, transform) => (transform ? transform(str, rawData) : str), str);
         }
         catch (e) {
             console.error(`An error occurred while applying modifiers to ${str}`, modifiers, e);
@@ -180,4 +183,73 @@ class Interpolator {
     }
 }
 
+function getInterpolationKeys(...interpolationStrings) {
+    return interpolationStrings.reduce((keys, str) => [...keys, ...(str ? stringInterpolator.parseRules(str).map((match) => match.key) : [])], []);
+}
+function parseInterpolationStrings(interpolationStrings, argTypeMap) {
+    const interpolationKeys = getInterpolationKeys(...interpolationStrings);
+    const args = {};
+    const contextVariables = [];
+    for (const interpolationKey of interpolationKeys) {
+        const interpolationKeyParts = interpolationKey.split('.');
+        const varName = interpolationKeyParts[interpolationKeyParts.length - 1];
+        if (interpolationKeyParts[0] === 'args') {
+            const argType = argTypeMap && varName in argTypeMap ? argTypeMap[varName] : 'ID';
+            args[varName] = {
+                type: argType,
+            };
+        }
+        else if (interpolationKeyParts[0] === 'context') {
+            contextVariables.push(varName);
+        }
+    }
+    return {
+        args,
+        contextVariables,
+    };
+}
+function getInterpolatedStringFactory(nonInterpolatedString) {
+    return resolverData => stringInterpolator.parse(nonInterpolatedString, resolverData);
+}
+function getInterpolatedHeadersFactory(nonInterpolatedHeaders = {}) {
+    return resolverData => {
+        const headers = {};
+        for (const headerName in nonInterpolatedHeaders) {
+            const headerValue = nonInterpolatedHeaders[headerName];
+            if (headerValue) {
+                headers[headerName.toLowerCase()] = stringInterpolator.parse(headerValue, resolverData);
+            }
+        }
+        return headers;
+    };
+}
+
+const hashCode = (s) => s.split('').reduce((a, b) => ((a << 5) - a + b.charCodeAt(0)) | 0, 0);
+function hashObject(value) {
+    return hashCode(JSON.stringify(value)).toString();
+}
+const stringInterpolator = new Interpolator({
+    delimiter: ['{', '}'],
+});
+stringInterpolator.addAlias('typeName', 'info.parentType.name');
+stringInterpolator.addAlias('type', 'info.parentType.name');
+stringInterpolator.addAlias('parentType', 'info.parentType.name');
+stringInterpolator.addAlias('fieldName', 'info.fieldName');
+stringInterpolator.registerModifier('date', (formatStr) => dayjs(new Date()).format(formatStr));
+stringInterpolator.registerModifier('hash', (value) => hashObject(value));
+stringInterpolator.registerModifier('base64', (value) => {
+    if (globalThis.Buffer.from) {
+        return globalThis.Buffer.from(value).toString('base64');
+    }
+    else {
+        return btoa(value);
+    }
+});
+
 exports.Interpolator = Interpolator;
+exports.getInterpolatedHeadersFactory = getInterpolatedHeadersFactory;
+exports.getInterpolatedStringFactory = getInterpolatedStringFactory;
+exports.getInterpolationKeys = getInterpolationKeys;
+exports.hashObject = hashObject;
+exports.parseInterpolationStrings = parseInterpolationStrings;
+exports.stringInterpolator = stringInterpolator;

package/dist/index.mjs

@@ -1,5 +1,6 @@
-import _ from 'lodash';
+import lodashGet from 'lodash.get';
 import JsonPointer from 'json-pointer';
+import dayjs from 'dayjs';
 
 const defaultOptions = {
     delimiter: ['{', '}'],
@@ -11,7 +12,8 @@ const lowercase = value => value.toLowerCase();
 
 const titlecase = value => value.replace(/\w\S*/g, s => s.charAt(0).toUpperCase() + s.substr(1).toLowerCase());
 
-const defaultModifiers = [{
+const defaultModifiers = [
+    {
         key: 'uppercase',
         transform: uppercase,
     },
@@ -22,7 +24,8 @@ const defaultModifiers = [{
     {
         key: 'title',
         transform: titlecase,
-    }];
+    },
+];
 
 class Interpolator {
     constructor(options = defaultOptions) {
@@ -62,20 +65,20 @@ class Interpolator {
         return matches ? this.extractRules(matches) : [];
     }
     extractRules(matches) {
-        return matches.map((match) => {
+        return matches.map(match => {
             const alternativeText = this.getAlternativeText(match);
             const modifiers = this.getModifiers(match);
             return {
                 key: this.getKeyFromMatch(match),
                 replace: match,
                 modifiers,
-                alternativeText
+                alternativeText,
             };
         });
     }
     getKeyFromMatch(match) {
         const removeReservedSymbols = [':', '|'];
-        return this.removeDelimiter(removeReservedSymbols.reduce((val, sym) => val.indexOf(sym) > 0 ? this.removeAfter(val, sym) : val, match));
+        return this.removeDelimiter(removeReservedSymbols.reduce((val, sym) => (val.indexOf(sym) > 0 ? this.removeAfter(val, sym) : val), match));
     }
     removeDelimiter(val) {
         return val.replace(new RegExp(this.delimiterStart(), 'g'), '').replace(new RegExp(this.delimiterEnd(), 'g'), '');
@@ -132,7 +135,7 @@ class Interpolator {
     }
     applyData(key, data) {
         const [prop, ptr] = key.split('#');
-        const propData = _.get(data, prop);
+        const propData = lodashGet(data, prop);
         if (ptr) {
             try {
                 return JsonPointer.get(propData, ptr);
@@ -152,7 +155,7 @@ class Interpolator {
     applyModifiers(modifiers, str, rawData) {
         try {
             const transformers = modifiers.map(modifier => modifier && modifier.transform);
-            return transformers.reduce((str, transform) => transform ? transform(str, rawData) : str, str);
+            return transformers.reduce((str, transform) => (transform ? transform(str, rawData) : str), str);
         }
         catch (e) {
             console.error(`An error occurred while applying modifiers to ${str}`, modifiers, e);
@@ -174,4 +177,67 @@ class Interpolator {
     }
 }
 
-export { Interpolator };
+function getInterpolationKeys(...interpolationStrings) {
+    return interpolationStrings.reduce((keys, str) => [...keys, ...(str ? stringInterpolator.parseRules(str).map((match) => match.key) : [])], []);
+}
+function parseInterpolationStrings(interpolationStrings, argTypeMap) {
+    const interpolationKeys = getInterpolationKeys(...interpolationStrings);
+    const args = {};
+    const contextVariables = [];
+    for (const interpolationKey of interpolationKeys) {
+        const interpolationKeyParts = interpolationKey.split('.');
+        const varName = interpolationKeyParts[interpolationKeyParts.length - 1];
+        if (interpolationKeyParts[0] === 'args') {
+            const argType = argTypeMap && varName in argTypeMap ? argTypeMap[varName] : 'ID';
+            args[varName] = {
+                type: argType,
+            };
+        }
+        else if (interpolationKeyParts[0] === 'context') {
+            contextVariables.push(varName);
+        }
+    }
+    return {
+        args,
+        contextVariables,
+    };
+}
+function getInterpolatedStringFactory(nonInterpolatedString) {
+    return resolverData => stringInterpolator.parse(nonInterpolatedString, resolverData);
+}
+function getInterpolatedHeadersFactory(nonInterpolatedHeaders = {}) {
+    return resolverData => {
+        const headers = {};
+        for (const headerName in nonInterpolatedHeaders) {
+            const headerValue = nonInterpolatedHeaders[headerName];
+            if (headerValue) {
+                headers[headerName.toLowerCase()] = stringInterpolator.parse(headerValue, resolverData);
+            }
+        }
+        return headers;
+    };
+}
+
+const hashCode = (s) => s.split('').reduce((a, b) => ((a << 5) - a + b.charCodeAt(0)) | 0, 0);
+function hashObject(value) {
+    return hashCode(JSON.stringify(value)).toString();
+}
+const stringInterpolator = new Interpolator({
+    delimiter: ['{', '}'],
+});
+stringInterpolator.addAlias('typeName', 'info.parentType.name');
+stringInterpolator.addAlias('type', 'info.parentType.name');
+stringInterpolator.addAlias('parentType', 'info.parentType.name');
+stringInterpolator.addAlias('fieldName', 'info.fieldName');
+stringInterpolator.registerModifier('date', (formatStr) => dayjs(new Date()).format(formatStr));
+stringInterpolator.registerModifier('hash', (value) => hashObject(value));
+stringInterpolator.registerModifier('base64', (value) => {
+    if (globalThis.Buffer.from) {
+        return globalThis.Buffer.from(value).toString('base64');
+    }
+    else {
+        return btoa(value);
+    }
+});
+
+export { Interpolator, getInterpolatedHeadersFactory, getInterpolatedStringFactory, getInterpolationKeys, hashObject, parseInterpolationStrings, stringInterpolator };

package/dist/package.json

@@ -1,11 +1,15 @@
 {
   "name": "@graphql-mesh/string-interpolation",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Dynamic string manipulation",
   "sideEffects": false,
+  "peerDependencies": {
+    "graphql": "*"
+  },
   "dependencies": {
+    "dayjs": "1.11.2",
     "json-pointer": "0.6.2",
-    "lodash": "^4.17.21"
+    "lodash.get": "4.4.2"
   },
   "repository": {
     "type": "git",

package/dist/resolver-data-factory.d.ts

@@ -0,0 +1,19 @@
+import { GraphQLInputType, GraphQLResolveInfo } from 'graphql';
+export declare type ResolverData<TParent = any, TArgs = any, TContext = any, TResult = any> = {
+    root?: TParent;
+    args?: TArgs;
+    context?: TContext;
+    info?: GraphQLResolveInfo;
+    result?: TResult;
+    env: Record<string, string>;
+};
+export declare type ResolverDataBasedFactory<T> = (data: ResolverData) => T;
+export declare function getInterpolationKeys(...interpolationStrings: string[]): any[];
+export declare function parseInterpolationStrings(interpolationStrings: string[], argTypeMap?: Record<string, string | GraphQLInputType>): {
+    args: Record<string, {
+        type: string | GraphQLInputType;
+    }>;
+    contextVariables: string[];
+};
+export declare function getInterpolatedStringFactory(nonInterpolatedString: string): ResolverDataBasedFactory<string>;
+export declare function getInterpolatedHeadersFactory(nonInterpolatedHeaders?: Record<string, string>): ResolverDataBasedFactory<Record<string, string>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-mesh/string-interpolation",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Dynamic string manipulation",
   "sideEffects": false,
   "main": "dist/index.js",
@@ -19,9 +19,13 @@
       "import": "./dist/*.mjs"
     }
   },
+  "peerDependencies": {
+    "graphql": "*"
+  },
   "dependencies": {
     "json-pointer": "0.6.2",
-    "lodash": "^4.17.21"
+    "dayjs": "1.11.2",
+    "lodash.get": "4.4.2"
   },
   "author": "Arda TANRIKULU <ardatanrikulu@gmail.com>",
   "repository": {

package/src/index.ts

@@ -1,3 +1,30 @@
 import { Interpolator } from './interpolator';
+import dayjs from 'dayjs';
+
+const hashCode = (s: string) => s.split('').reduce((a, b) => ((a << 5) - a + b.charCodeAt(0)) | 0, 0);
+
+export function hashObject(value: any): string {
+  return hashCode(JSON.stringify(value)).toString();
+}
 
 export { Interpolator };
+
+export const stringInterpolator = new Interpolator({
+  delimiter: ['{', '}'],
+});
+
+stringInterpolator.addAlias('typeName', 'info.parentType.name');
+stringInterpolator.addAlias('type', 'info.parentType.name');
+stringInterpolator.addAlias('parentType', 'info.parentType.name');
+stringInterpolator.addAlias('fieldName', 'info.fieldName');
+stringInterpolator.registerModifier('date', (formatStr: string) => dayjs(new Date()).format(formatStr));
+stringInterpolator.registerModifier('hash', (value: any) => hashObject(value));
+stringInterpolator.registerModifier('base64', (value: any) => {
+  if (globalThis.Buffer.from) {
+    return globalThis.Buffer.from(value).toString('base64');
+  } else {
+    return btoa(value);
+  }
+});
+
+export * from './resolver-data-factory';

package/src/interpolator.js

@@ -1,5 +1,5 @@
 import { defaultOptions } from './statics/DefaultOptions';
-import _ from 'lodash';
+import lodashGet from 'lodash.get';
 import { defaultModifiers } from './modifiers';
 import JsonPointer from 'json-pointer';
 
@@ -37,7 +37,7 @@ export class Interpolator {
       return new Error('Modifiers must have a transformer. Transformers must be a function that returns a value.');
     }
 
-    this.modifiers.push({key: key.toLowerCase(), transform});
+    this.modifiers.push({ key: key.toLowerCase(), transform });
     return this;
   }
 
@@ -51,21 +51,23 @@ export class Interpolator {
   }
 
   extractRules(matches) {
-    return matches.map((match) => {
+    return matches.map(match => {
       const alternativeText = this.getAlternativeText(match);
       const modifiers = this.getModifiers(match);
       return {
         key: this.getKeyFromMatch(match),
         replace: match,
         modifiers,
-        alternativeText
-      }
-    })
+        alternativeText,
+      };
+    });
   }
 
   getKeyFromMatch(match) {
     const removeReservedSymbols = [':', '|'];
-    return this.removeDelimiter(removeReservedSymbols.reduce((val, sym) => val.indexOf(sym) > 0 ? this.removeAfter(val, sym) : val, match));
+    return this.removeDelimiter(
+      removeReservedSymbols.reduce((val, sym) => (val.indexOf(sym) > 0 ? this.removeAfter(val, sym) : val), match)
+    );
   }
 
   removeDelimiter(val) {
@@ -135,10 +137,10 @@ export class Interpolator {
 
   applyData(key, data) {
     const [prop, ptr] = key.split('#');
-    const propData = _.get(data, prop);
+    const propData = lodashGet(data, prop);
     if (ptr) {
       try {
-          return JsonPointer.get(propData, ptr);
+        return JsonPointer.get(propData, ptr);
       } catch (e) {
         if (e.message.startsWith('Invalid reference')) {
           return undefined;
@@ -156,7 +158,7 @@ export class Interpolator {
   applyModifiers(modifiers, str, rawData) {
     try {
       const transformers = modifiers.map(modifier => modifier && modifier.transform);
-      return transformers.reduce((str, transform) => transform ? transform(str, rawData) : str, str);
+      return transformers.reduce((str, transform) => (transform ? transform(str, rawData) : str), str);
     } catch (e) {
       console.error(`An error occurred while applying modifiers to ${str}`, modifiers, e);
       return str;
@@ -164,8 +166,8 @@ export class Interpolator {
   }
 
   addAlias(key, ref) {
-    if (typeof ref === 'function'){
-      this.aliases.push({key, ref: ref() });
+    if (typeof ref === 'function') {
+      this.aliases.push({ key, ref: ref() });
     } else {
       this.aliases.push({ key, ref });
     }

package/src/modifiers/index.js

@@ -2,15 +2,17 @@ import { uppercase } from './uppercase';
 import { lowercase } from './lowercase';
 import { titlecase } from './title';
 
-export const defaultModifiers = [{
-  key: 'uppercase',
-  transform: uppercase,
-},
-{
-  key: 'lowercase',
-  transform: lowercase,
-},
-{
-  key: 'title',
-  transform: titlecase,
-}];
+export const defaultModifiers = [
+  {
+    key: 'uppercase',
+    transform: uppercase,
+  },
+  {
+    key: 'lowercase',
+    transform: lowercase,
+  },
+  {
+    key: 'title',
+    transform: titlecase,
+  },
+];

package/src/resolver-data-factory.ts

@@ -0,0 +1,66 @@
+import { stringInterpolator } from './index';
+import { GraphQLInputType, GraphQLResolveInfo } from 'graphql';
+
+export type ResolverData<TParent = any, TArgs = any, TContext = any, TResult = any> = {
+  root?: TParent;
+  args?: TArgs;
+  context?: TContext;
+  info?: GraphQLResolveInfo;
+  result?: TResult;
+  env: Record<string, string>;
+};
+export type ResolverDataBasedFactory<T> = (data: ResolverData) => T;
+
+export function getInterpolationKeys(...interpolationStrings: string[]) {
+  return interpolationStrings.reduce(
+    (keys, str) => [...keys, ...(str ? stringInterpolator.parseRules(str).map((match: any) => match.key) : [])],
+    [] as string[]
+  );
+}
+
+export function parseInterpolationStrings(
+  interpolationStrings: string[],
+  argTypeMap?: Record<string, string | GraphQLInputType>
+) {
+  const interpolationKeys = getInterpolationKeys(...interpolationStrings);
+
+  const args: Record<string, { type: string | GraphQLInputType }> = {};
+  const contextVariables: string[] = [];
+
+  for (const interpolationKey of interpolationKeys) {
+    const interpolationKeyParts = interpolationKey.split('.');
+    const varName = interpolationKeyParts[interpolationKeyParts.length - 1];
+    if (interpolationKeyParts[0] === 'args') {
+      const argType = argTypeMap && varName in argTypeMap ? argTypeMap[varName] : 'ID';
+      args[varName] = {
+        type: argType,
+      };
+    } else if (interpolationKeyParts[0] === 'context') {
+      contextVariables.push(varName);
+    }
+  }
+
+  return {
+    args,
+    contextVariables,
+  };
+}
+
+export function getInterpolatedStringFactory(nonInterpolatedString: string): ResolverDataBasedFactory<string> {
+  return resolverData => stringInterpolator.parse(nonInterpolatedString, resolverData);
+}
+
+export function getInterpolatedHeadersFactory(
+  nonInterpolatedHeaders: Record<string, string> = {}
+): ResolverDataBasedFactory<Record<string, string>> {
+  return resolverData => {
+    const headers: Record<string, string> = {};
+    for (const headerName in nonInterpolatedHeaders) {
+      const headerValue = nonInterpolatedHeaders[headerName];
+      if (headerValue) {
+        headers[headerName.toLowerCase()] = stringInterpolator.parse(headerValue, resolverData);
+      }
+    }
+    return headers;
+  };
+}

package/src/statics/DefaultOptions.js

@@ -1,3 +1,3 @@
 export const defaultOptions = {
   delimiter: ['{', '}'],
-}
+};