graphile-i18n 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Dan Lynch <pyramation@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,59 @@
+# graphile-i18n [![Build Status](https://travis-ci.com/pyramation/graphile-i18n.svg?branch=master)](https://travis-ci.com/pyramation/graphile-i18n)
+
+```sh
+npm install graphile-i18n 
+```
+
+This [PostGraphile](http://postgraphile.org/) schema plugin was built to enable i18n language translation tables.
+
+## Usage
+
+1. Create a language translation table
+2. Add smart comments
+3. Register plugin with postgraphile
+
+## language table
+
+Add language table with `lang_code` field and a smart comment for `i18n`:
+
+```sql
+CREATE TABLE app_public.projects (
+    id serial PRIMARY KEY,
+    name citext,
+    description citext
+);
+COMMENT ON TABLE app_public.projects IS E'@i18n project_language_variations';
+
+CREATE TABLE app_public.project_language_variations (
+    id serial PRIMARY KEY,
+    project_id int NOT NULL REFERENCES app_public.projects(id),
+    lang_code citext,
+    name citext,
+    description citext,
+    UNIQUE(project_id, lang_code)
+);
+```
+
+## Register Plugin
+
+```js
+app.use(
+  postgraphile(connectionStr, schemas, {
+    appendPlugins: [
+      LangPlugin
+    ],
+    graphileBuildOptions: {
+      langPluginDefaultLanguages: ['en']
+    }
+  })
+);
+```
+
+## testing
+
+```
+createdb test_database
+psql test_database < sql/roles.sql
+psql test_database < sql/test.sql 
+yarn test
+```

package/main/env.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _envalid = require("envalid");
+
+var array = (0, _envalid.makeValidator)(function (x) {
+  return x.split(',');
+}, '');
+
+var _default = (0, _envalid.cleanEnv)(process.env, {
+  ACCEPTED_LANGUAGES: array({
+    "default": 'en,es'
+  })
+}, {
+  dotEnvPath: null
+});
+
+exports["default"] = _default;

package/main/index.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {};
+exports["default"] = void 0;
+
+var _plugin = require("./plugin");
+
+Object.keys(_plugin).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _plugin[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _plugin[key];
+    }
+  });
+});
+
+var _middleware = require("./middleware");
+
+Object.keys(_middleware).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _middleware[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _middleware[key];
+    }
+  });
+});
+var _default = _plugin.LangPlugin;
+exports["default"] = _default;

package/main/middleware.js

@@ -0,0 +1,95 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.makeLanguageDataLoaderForTable = exports.additionalGraphQLContextFromRequest = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _dataloader = _interopRequireDefault(require("dataloader"));
+
+var _acceptLanguageParser = _interopRequireDefault(require("accept-language-parser"));
+
+var _env = require("./env");
+
+var escapeIdentifier = function escapeIdentifier(str) {
+  return "\"".concat(str.replace(/"/g, '""'), "\"");
+};
+
+var makeLanguageDataLoaderForTable = function makeLanguageDataLoaderForTable(_req) {
+  var cache = new Map();
+  return function (props, pgClient, languageCodes, identifer, idType, sqlField, gqlField) {
+    var dataLoader = cache.get(props);
+
+    if (!dataLoader) {
+      var table = props.table,
+          coalescedFields = props.coalescedFields,
+          variationsTableName = props.variationsTableName,
+          key = props.key;
+      var schemaName = escapeIdentifier(table.namespaceName);
+      var baseTable = escapeIdentifier(table.name);
+      var variationTable = escapeIdentifier(variationsTableName);
+      var joinKey = escapeIdentifier(key);
+      var fields = coalescedFields.join(', ');
+      var b = [schemaName, baseTable].join('.');
+      var v = [schemaName, variationTable].join('.');
+      dataLoader = new _dataloader["default"]( /*#__PURE__*/function () {
+        var _ref = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(ids) {
+          var _yield$pgClient$query, rows;
+
+          return _regenerator["default"].wrap(function _callee$(_context) {
+            while (1) {
+              switch (_context.prev = _context.next) {
+                case 0:
+                  _context.next = 2;
+                  return pgClient.query("\n            select *\n            from unnest($1::".concat(idType, "[]) ids(").concat(identifer, ")\n            inner join lateral (\n              select b.").concat(identifer, ", v.").concat(sqlField, " as \"").concat(gqlField, "\", ").concat(fields, "\n              from ").concat(b, " b\n              left join ").concat(v, " v\n              on (v.").concat(joinKey, " = b.").concat(identifer, " and array_position($2, ").concat(sqlField, ") is not null)\n              where b.").concat(identifer, " = ids.").concat(identifer, "\n              order by array_position($2, ").concat(sqlField, ") asc nulls last\n              limit 1\n            ) tmp on (true)\n            "), [ids, languageCodes]);
+
+                case 2:
+                  _yield$pgClient$query = _context.sent;
+                  rows = _yield$pgClient$query.rows;
+                  return _context.abrupt("return", ids.map(function (id) {
+                    return rows.find(function (r) {
+                      return r.id === id;
+                    });
+                  }));
+
+                case 5:
+                case "end":
+                  return _context.stop();
+              }
+            }
+          }, _callee);
+        }));
+
+        return function (_x) {
+          return _ref.apply(this, arguments);
+        };
+      }());
+      cache.set(props, dataLoader);
+    }
+
+    return dataLoader;
+  };
+};
+
+exports.makeLanguageDataLoaderForTable = makeLanguageDataLoaderForTable;
+
+var additionalGraphQLContextFromRequest = function additionalGraphQLContextFromRequest(req, res) {
+  var language = _acceptLanguageParser["default"].pick(_env.ACCEPTED_LANGUAGES, req.get('accept-language')); // Accept-Language: *
+  // Accept-Language: en-US,en;q=0.5
+  // Accept-Language: fr-CH, fr;q=0.9, en;q=0.8, de;q=0.7, *;q=0.5
+
+
+  return {
+    langCodes: [language],
+    // in future make fallback languages
+    getLanguageDataLoader: makeLanguageDataLoaderForTable(req)
+  };
+};
+
+exports.additionalGraphQLContextFromRequest = additionalGraphQLContextFromRequest;

package/main/plugin.js

@@ -0,0 +1,206 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LangPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _taggedTemplateLiteral2 = _interopRequireDefault(require("@babel/runtime/helpers/taggedTemplateLiteral"));
+
+var _templateObject;
+
+var escapeIdentifier = function escapeIdentifier(str) {
+  return "\"".concat(str.replace(/"/g, '""'), "\"");
+};
+
+var LangPlugin = function LangPlugin(builder, options) {
+  var _options$langPluginLa = options.langPluginLanguageCodeColumn,
+      langPluginLanguageCodeColumn = _options$langPluginLa === void 0 ? 'lang_code' : _options$langPluginLa,
+      _options$langPluginLa2 = options.langPluginLanguageCodeGqlField,
+      langPluginLanguageCodeGqlField = _options$langPluginLa2 === void 0 ? 'langCode' : _options$langPluginLa2,
+      _options$langPluginAl = options.langPluginAllowedTypes,
+      langPluginAllowedTypes = _options$langPluginAl === void 0 ? ['citext', 'text'] : _options$langPluginAl,
+      _options$langPluginDe = options.langPluginDefaultLanguages,
+      langPluginDefaultLanguages = _options$langPluginDe === void 0 ? ['en'] : _options$langPluginDe;
+  builder.hook('build', function (build) {
+    var sql = build.pgSql;
+    /** @type {import('graphile-build-pg').PgIntrospectionResultsByKind} */
+
+    var introspection = build.pgIntrospectionResultsByKind;
+    var inflection = build.inflection;
+    var tablesWithLanguageTables = introspection["class"].filter(function (table) {
+      return table.tags.hasOwnProperty('i18n');
+    });
+    var tablesWithLanguageTablesIdInfo = introspection["class"].filter(function (table) {
+      return table.tags.hasOwnProperty('i18n');
+    }).map(function (table) {
+      return {
+        identifier: table.primaryKeyConstraint.keyAttributes[0].name,
+        idType: table.primaryKeyConstraint.keyAttributes[0].type.name
+      };
+    });
+    var languageVariationTables = tablesWithLanguageTables.map(function (table) {
+      return introspection["class"].find(function (t) {
+        return t.name === table.tags.i18n && t.namespaceName === table.namespaceName;
+      });
+    });
+    var i18nTables = {};
+    var tables = {};
+    tablesWithLanguageTables.forEach(function (table, i) {
+      i18nTables[table.tags.i18n] = {
+        table: table.name,
+        key: null,
+        // action_id
+        connection: inflection.connection(inflection.tableType(table)),
+        attrs: {},
+        fields: {},
+        keyInfo: tablesWithLanguageTablesIdInfo[i]
+      };
+      tables[table.name] = table.tags.i18n;
+    });
+    languageVariationTables.forEach(function (table) {
+      var foreignConstraintsThatMatter = table.constraints.filter(function (c) {
+        return c.type === 'f';
+      }).filter(function (c) {
+        return c.foreignClass.name === i18nTables[table.name].table;
+      });
+      if (foreignConstraintsThatMatter.length !== 1) throw new Error('lang table only supports one foreign key to parent table');
+      if (foreignConstraintsThatMatter[0].keyAttributes.length !== 1) throw new Error('lang table only supports one non compound foreign key to parent table');
+      i18nTables[table.name].key = foreignConstraintsThatMatter[0].keyAttributes[0].name;
+      var _i18nTables$table$nam = i18nTables[table.name].keyInfo,
+          identifier = _i18nTables$table$nam.identifier,
+          idType = _i18nTables$table$nam.idType;
+      table.attributes.forEach(function (attr) {
+        if ([langPluginLanguageCodeColumn, identifier].includes(attr.name)) return;
+
+        if (langPluginAllowedTypes.includes(attr.type.name)) {
+          i18nTables[table.name].fields[inflection.column(attr)] = {
+            type: attr.type.name,
+            attr: attr.name,
+            isNotNull: attr.isNotNull,
+            column: inflection.column(attr)
+          };
+          i18nTables[table.name].attrs[attr.name] = {
+            type: attr.type.name,
+            attr: attr.name,
+            column: inflection.column(attr)
+          };
+        }
+      });
+    });
+    return build.extend(build, {
+      i18n: {
+        i18nTables: i18nTables,
+        tables: tables
+      }
+    });
+  });
+  builder.hook('GraphQLObjectType:fields', function (fields, build, context) {
+    var _build$graphql = build.graphql,
+        GraphQLString = _build$graphql.GraphQLString,
+        GraphQLObjectType = _build$graphql.GraphQLObjectType,
+        GraphQLNonNull = _build$graphql.GraphQLNonNull,
+        _build$i18n = build.i18n,
+        i18nTables = _build$i18n.i18nTables,
+        tables = _build$i18n.tables,
+        sql = build.pgSql;
+    var _context$scope = context.scope,
+        table = _context$scope.pgIntrospection,
+        isPgRowType = _context$scope.isPgRowType,
+        fieldWithHooks = context.fieldWithHooks;
+
+    if (!isPgRowType || !table || table.kind !== 'class') {
+      return fields;
+    }
+
+    var variationsTableName = tables[table.name];
+
+    if (!variationsTableName) {
+      return fields;
+    }
+
+    var i18nTable = i18nTables[variationsTableName];
+    var _i18nTable$keyInfo = i18nTable.keyInfo,
+        identifier = _i18nTable$keyInfo.identifier,
+        idType = _i18nTable$keyInfo.idType;
+    var key = i18nTable.key,
+        connection = i18nTable.connection,
+        attrs = i18nTable.attrs,
+        i18nFields = i18nTable.fields;
+    var localeFieldName = 'localeStrings';
+    var localeFieldsType = new GraphQLObjectType({
+      name: "".concat(context.Self.name, "LocaleStrings"),
+      description: "Locales for ".concat(context.Self.name),
+      fields: Object.keys(i18nFields).reduce(function (memo, field) {
+        memo[field] = {
+          type: i18nFields[field].isNotNull ? new GraphQLNonNull(GraphQLString) : GraphQLString,
+          description: "Locale for ".concat(field)
+        };
+        return memo;
+      }, {
+        langCode: {
+          type: GraphQLString // MUST BE NULLABLE
+
+        }
+      })
+    });
+    return build.extend(fields, (0, _defineProperty2["default"])({}, localeFieldName, fieldWithHooks(localeFieldName, function (fieldContext) {
+      var addDataGenerator = fieldContext.addDataGenerator;
+      addDataGenerator(function (parsedResolveInfoFragment) {
+        return {
+          pgQuery: function pgQuery(queryBuilder) {
+            queryBuilder.select(sql.fragment(_templateObject || (_templateObject = (0, _taggedTemplateLiteral2["default"])(["", ".", ""])), queryBuilder.getTableAlias(), sql.identifier(identifier)), identifier);
+          }
+        };
+      });
+      var coalescedFields = Object.keys(i18nFields).map(function (field) {
+        var columnName = i18nFields[field].attr;
+        var escColumnName = escapeIdentifier(columnName);
+        var escFieldName = escapeIdentifier(field);
+        return "coalesce(v.".concat(escColumnName, ", b.").concat(escColumnName, ") as ").concat(escFieldName);
+      });
+      var props = {
+        table: table,
+        coalescedFields: coalescedFields,
+        variationsTableName: variationsTableName,
+        key: key
+      };
+      return {
+        description: "Locales for ".concat(context.Self.name),
+        type: new GraphQLNonNull(localeFieldsType),
+        resolve: function resolve(_ref, args, context) {
+          return (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+            var _context$langCodes;
+
+            var id, languageCodes, dataloader;
+            return _regenerator["default"].wrap(function _callee$(_context) {
+              while (1) {
+                switch (_context.prev = _context.next) {
+                  case 0:
+                    id = _ref.id;
+                    languageCodes = (_context$langCodes = context.langCodes) !== null && _context$langCodes !== void 0 ? _context$langCodes : langPluginDefaultLanguages;
+                    dataloader = context.getLanguageDataLoader(props, context.pgClient, languageCodes, identifier, idType, langPluginLanguageCodeColumn, langPluginLanguageCodeGqlField);
+                    return _context.abrupt("return", dataloader.load(id));
+
+                  case 4:
+                  case "end":
+                    return _context.stop();
+                }
+              }
+            }, _callee);
+          }))();
+        }
+      };
+    }, 'Adding the language code field from the lang plugin')));
+  });
+};
+
+exports.LangPlugin = LangPlugin;

package/module/env.js

@@ -0,0 +1,9 @@
+import { cleanEnv, makeValidator } from 'envalid';
+const array = makeValidator(x => x.split(','), '');
+export default cleanEnv(process.env, {
+  ACCEPTED_LANGUAGES: array({
+    default: 'en,es'
+  })
+}, {
+  dotEnvPath: null
+});

package/module/index.js

@@ -0,0 +1,4 @@
+export * from './plugin';
+export * from './middleware';
+import { LangPlugin } from './plugin';
+export default LangPlugin;

package/module/middleware.js

@@ -0,0 +1,60 @@
+import DataLoader from 'dataloader';
+import langParser from 'accept-language-parser';
+import { ACCEPTED_LANGUAGES } from './env';
+
+const escapeIdentifier = str => `"${str.replace(/"/g, '""')}"`;
+
+export const makeLanguageDataLoaderForTable = _req => {
+  const cache = new Map();
+  return (props, pgClient, languageCodes, identifer, idType, sqlField, gqlField) => {
+    let dataLoader = cache.get(props);
+
+    if (!dataLoader) {
+      const {
+        table,
+        coalescedFields,
+        variationsTableName,
+        key
+      } = props;
+      const schemaName = escapeIdentifier(table.namespaceName);
+      const baseTable = escapeIdentifier(table.name);
+      const variationTable = escapeIdentifier(variationsTableName);
+      const joinKey = escapeIdentifier(key);
+      const fields = coalescedFields.join(', ');
+      const b = [schemaName, baseTable].join('.');
+      const v = [schemaName, variationTable].join('.');
+      dataLoader = new DataLoader(async ids => {
+        const {
+          rows
+        } = await pgClient.query(`
+            select *
+            from unnest($1::${idType}[]) ids(${identifer})
+            inner join lateral (
+              select b.${identifer}, v.${sqlField} as "${gqlField}", ${fields}
+              from ${b} b
+              left join ${v} v
+              on (v.${joinKey} = b.${identifer} and array_position($2, ${sqlField}) is not null)
+              where b.${identifer} = ids.${identifer}
+              order by array_position($2, ${sqlField}) asc nulls last
+              limit 1
+            ) tmp on (true)
+            `, [ids, languageCodes]);
+        return ids.map(id => rows.find(r => r.id === id));
+      });
+      cache.set(props, dataLoader);
+    }
+
+    return dataLoader;
+  };
+};
+export const additionalGraphQLContextFromRequest = (req, res) => {
+  const language = langParser.pick(ACCEPTED_LANGUAGES, req.get('accept-language')); // Accept-Language: *
+  // Accept-Language: en-US,en;q=0.5
+  // Accept-Language: fr-CH, fr;q=0.9, en;q=0.8, de;q=0.7, *;q=0.5
+
+  return {
+    langCodes: [language],
+    // in future make fallback languages
+    getLanguageDataLoader: makeLanguageDataLoaderForTable(req)
+  };
+};

package/module/plugin.js

@@ -0,0 +1,173 @@
+const escapeIdentifier = str => `"${str.replace(/"/g, '""')}"`;
+
+export const LangPlugin = (builder, options) => {
+  const {
+    langPluginLanguageCodeColumn = 'lang_code',
+    langPluginLanguageCodeGqlField = 'langCode',
+    langPluginAllowedTypes = ['citext', 'text'],
+    langPluginDefaultLanguages = ['en']
+  } = options;
+  builder.hook('build', build => {
+    const {
+      pgSql: sql
+    } = build;
+    /** @type {import('graphile-build-pg').PgIntrospectionResultsByKind} */
+
+    const introspection = build.pgIntrospectionResultsByKind;
+    const inflection = build.inflection;
+    const tablesWithLanguageTables = introspection.class.filter(table => table.tags.hasOwnProperty('i18n'));
+    const tablesWithLanguageTablesIdInfo = introspection.class.filter(table => table.tags.hasOwnProperty('i18n')).map(table => {
+      return {
+        identifier: table.primaryKeyConstraint.keyAttributes[0].name,
+        idType: table.primaryKeyConstraint.keyAttributes[0].type.name
+      };
+    });
+    const languageVariationTables = tablesWithLanguageTables.map(table => introspection.class.find(t => t.name === table.tags.i18n && t.namespaceName === table.namespaceName));
+    const i18nTables = {};
+    const tables = {};
+    tablesWithLanguageTables.forEach((table, i) => {
+      i18nTables[table.tags.i18n] = {
+        table: table.name,
+        key: null,
+        // action_id
+        connection: inflection.connection(inflection.tableType(table)),
+        attrs: {},
+        fields: {},
+        keyInfo: tablesWithLanguageTablesIdInfo[i]
+      };
+      tables[table.name] = table.tags.i18n;
+    });
+    languageVariationTables.forEach(table => {
+      const foreignConstraintsThatMatter = table.constraints.filter(c => c.type === 'f').filter(c => c.foreignClass.name === i18nTables[table.name].table);
+      if (foreignConstraintsThatMatter.length !== 1) throw new Error('lang table only supports one foreign key to parent table');
+      if (foreignConstraintsThatMatter[0].keyAttributes.length !== 1) throw new Error('lang table only supports one non compound foreign key to parent table');
+      i18nTables[table.name].key = foreignConstraintsThatMatter[0].keyAttributes[0].name;
+      const {
+        identifier,
+        idType
+      } = i18nTables[table.name].keyInfo;
+      table.attributes.forEach(attr => {
+        if ([langPluginLanguageCodeColumn, identifier].includes(attr.name)) return;
+
+        if (langPluginAllowedTypes.includes(attr.type.name)) {
+          i18nTables[table.name].fields[inflection.column(attr)] = {
+            type: attr.type.name,
+            attr: attr.name,
+            isNotNull: attr.isNotNull,
+            column: inflection.column(attr)
+          };
+          i18nTables[table.name].attrs[attr.name] = {
+            type: attr.type.name,
+            attr: attr.name,
+            column: inflection.column(attr)
+          };
+        }
+      });
+    });
+    return build.extend(build, {
+      i18n: {
+        i18nTables,
+        tables
+      }
+    });
+  });
+  builder.hook('GraphQLObjectType:fields', (fields, build, context) => {
+    const {
+      graphql: {
+        GraphQLString,
+        GraphQLObjectType,
+        GraphQLNonNull
+      },
+      i18n: {
+        i18nTables,
+        tables
+      },
+      pgSql: sql
+    } = build;
+    const {
+      scope: {
+        pgIntrospection: table,
+        isPgRowType
+      },
+      fieldWithHooks
+    } = context;
+
+    if (!isPgRowType || !table || table.kind !== 'class') {
+      return fields;
+    }
+
+    const variationsTableName = tables[table.name];
+
+    if (!variationsTableName) {
+      return fields;
+    }
+
+    const i18nTable = i18nTables[variationsTableName];
+    const {
+      identifier,
+      idType
+    } = i18nTable.keyInfo;
+    const {
+      key,
+      connection,
+      attrs,
+      fields: i18nFields
+    } = i18nTable;
+    const localeFieldName = 'localeStrings';
+    const localeFieldsType = new GraphQLObjectType({
+      name: `${context.Self.name}LocaleStrings`,
+      description: `Locales for ${context.Self.name}`,
+      fields: Object.keys(i18nFields).reduce((memo, field) => {
+        memo[field] = {
+          type: i18nFields[field].isNotNull ? new GraphQLNonNull(GraphQLString) : GraphQLString,
+          description: `Locale for ${field}`
+        };
+        return memo;
+      }, {
+        langCode: {
+          type: GraphQLString // MUST BE NULLABLE
+
+        }
+      })
+    });
+    return build.extend(fields, {
+      [localeFieldName]: fieldWithHooks(localeFieldName, fieldContext => {
+        const {
+          addDataGenerator
+        } = fieldContext;
+        addDataGenerator(parsedResolveInfoFragment => {
+          return {
+            pgQuery: queryBuilder => {
+              queryBuilder.select(sql.fragment`${queryBuilder.getTableAlias()}.${sql.identifier(identifier)}`, identifier);
+            }
+          };
+        });
+        const coalescedFields = Object.keys(i18nFields).map(field => {
+          const columnName = i18nFields[field].attr;
+          const escColumnName = escapeIdentifier(columnName);
+          const escFieldName = escapeIdentifier(field);
+          return `coalesce(v.${escColumnName}, b.${escColumnName}) as ${escFieldName}`;
+        });
+        const props = {
+          table,
+          coalescedFields,
+          variationsTableName,
+          key
+        };
+        return {
+          description: `Locales for ${context.Self.name}`,
+          type: new GraphQLNonNull(localeFieldsType),
+
+          async resolve({
+            id
+          }, args, context) {
+            const languageCodes = context.langCodes ?? langPluginDefaultLanguages;
+            const dataloader = context.getLanguageDataLoader(props, context.pgClient, languageCodes, identifier, idType, langPluginLanguageCodeColumn, langPluginLanguageCodeGqlField);
+            return dataloader.load(id);
+          }
+
+        };
+      }, 'Adding the language code field from the lang plugin')
+    });
+  });
+};

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "graphile-i18n",
+  "version": "0.0.1",
+  "description": "Graphile i18n plugin",
+  "author": "true <true>",
+  "homepage": "https://github.com/pyramation/graphile-i18n#readme",
+  "license": "SEE LICENSE IN LICENSE",
+  "main": "main/index.js",
+  "module": "module/index.js",
+  "directories": {
+    "lib": "src",
+    "test": "__tests__"
+  },
+  "files": [
+    "main",
+    "module"
+  ],
+  "scripts": {
+    "build:main": "cross-env BABEL_ENV=production babel src --out-dir main --delete-dir-on-start",
+    "build:module": "cross-env MODULE=true babel src --out-dir module --delete-dir-on-start",
+    "build": "npm run build:module && npm run build:main",
+    "prepublish": "npm run build",
+    "dev": "cross-env NODE_ENV=development babel-node src/index",
+    "watch": "cross-env NODE_ENV=development babel-watch src/index",
+    "lint": "eslint src --fix",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:debug": "node --inspect node_modules/.bin/jest --runInBand"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pyramation/graphile-i18n"
+  },
+  "keywords": [
+    "postgraphile",
+    "graphile",
+    "launchql",
+    "plugin",
+    "postgres",
+    "graphql"
+  ],
+  "resolutions": {
+    "graphql": "15.5.2"
+  },
+  "bugs": {
+    "url": "https://github.com/pyramation/graphile-i18n/issues"
+  },
+  "devDependencies": {
+    "@babel/cli": "7.11.6",
+    "@babel/core": "7.11.6",
+    "@babel/node": "^7.10.5",
+    "@babel/plugin-proposal-class-properties": "7.10.4",
+    "@babel/plugin-proposal-export-default-from": "7.10.4",
+    "@babel/plugin-proposal-object-rest-spread": "7.11.0",
+    "@babel/plugin-transform-runtime": "7.11.5",
+    "@babel/preset-env": "7.11.5",
+    "babel-core": "7.0.0-bridge.0",
+    "babel-eslint": "10.1.0",
+    "babel-jest": "25.1.0",
+    "babel-watch": "^7.0.0",
+    "cross-env": "^7.0.2",
+    "eslint": "6.8.0",
+    "eslint-config-prettier": "^6.10.0",
+    "eslint-plugin-prettier": "^3.1.2",
+    "graphile-test": "^0.1.1",
+    "jest": "^24.5.0",
+    "jest-in-case": "^1.0.2",
+    "prettier": "^2.1.2",
+    "regenerator-runtime": "^0.13.7"
+  },
+  "dependencies": {
+    "@babel/runtime": "^7.11.2",
+    "accept-language-parser": "^1.5.0",
+    "dataloader": "^2.0.0",
+    "envalid": "^6.0.2",
+    "graphile-build": "^4.9.0",
+    "graphile-utils": "^4.9.0"
+  }
+}