graphile-i18n 1.1.0 → 1.2.0

package/esm/plugin.js

@@ -1,147 +1,284 @@
-import { makeLanguageDataLoaderForTable } from './middleware';
-const defaultLanguageLoaderFactory = makeLanguageDataLoaderForTable();
-const escapeIdentifier = (str) => `"${str.replace(/"/g, '""')}"`;
-const hasI18nTag = (table) => Object.prototype.hasOwnProperty.call(table.tags, 'i18n');
-const getPrimaryKeyInfo = (table) => {
-    const identifier = table.primaryKeyConstraint?.keyAttributes?.[0]?.name;
-    const idType = table.primaryKeyConstraint?.keyAttributes?.[0]?.type?.name;
-    return { identifier, idType };
-};
-export const LangPlugin = (builder, options) => {
-    const { langPluginLanguageCodeColumn = 'lang_code', langPluginLanguageCodeGqlField = 'langCode', langPluginAllowedTypes = ['citext', 'text'], langPluginDefaultLanguages = ['en'] } = options;
-    builder.hook('build', (build) => {
-        const introspection = build.pgIntrospectionResultsByKind;
-        const inflection = build.inflection;
-        const tablesWithLanguageTables = introspection.class.filter(hasI18nTag);
-        const tablesWithLanguageTablesIdInfo = tablesWithLanguageTables.reduce((memo, table) => {
-            const keyInfo = getPrimaryKeyInfo(table);
-            if (table.tags.i18n) {
-                memo[table.tags.i18n] = keyInfo;
-            }
-            return memo;
-        }, {});
-        const languageVariationTables = tablesWithLanguageTables.map((table) => introspection.class.find((candidate) => candidate.name === table.tags.i18n &&
-            candidate.namespaceName === table.namespaceName));
-        const i18nTables = {};
-        const tables = {};
-        tablesWithLanguageTables.forEach((table) => {
-            const i18nTableName = table.tags.i18n;
-            i18nTables[i18nTableName] = {
-                table: table.name,
-                key: null,
-                connection: inflection.connection(inflection.tableType(table)),
-                attrs: {},
-                fields: {},
-                keyInfo: tablesWithLanguageTablesIdInfo[i18nTableName] ?? {}
-            };
-            tables[table.name] = i18nTableName;
-        });
-        languageVariationTables.forEach((table) => {
-            if (!table)
-                return;
-            const foreignConstraintsThatMatter = table.constraints
-                .filter((constraint) => constraint.type === 'f')
-                .filter((constraint) => constraint.foreignClass.name === i18nTables[table.name].table);
-            if (foreignConstraintsThatMatter.length !== 1) {
-                return;
-            }
-            const foreignKeyConstraint = foreignConstraintsThatMatter[0];
-            if (!foreignKeyConstraint || foreignKeyConstraint.keyAttributes.length !== 1) {
-                return;
-            }
-            i18nTables[table.name].key = foreignKeyConstraint.keyAttributes[0].name;
-            const { identifier } = i18nTables[table.name].keyInfo;
-            if (!identifier)
-                return;
-            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)
+/**
+ * PostGraphile v5 i18n Plugin
+ *
+ * Discovers tables tagged with @i18n and adds a `localeStrings` field to the
+ * base type. The field resolves the best-matching translation row based on
+ * language codes provided in the GraphQL context, falling back to the base
+ * table's own values when no translation exists.
+ *
+ * Smart tag format:
+ *   COMMENT ON TABLE app_public.posts IS E'@i18n posts_translations';
+ *
+ * The value of @i18n is the name of the translation table in the same schema.
+ * The translation table must have:
+ *   - A FK column referencing the base table's PK
+ *   - A lang_code column (configurable)
+ *   - UNIQUE(fk_column, lang_code)
+ *   - One or more text/citext columns matching the base table's columns
+ */
+import 'graphile-build';
+import 'graphile-build-pg';
+import { TYPES } from '@dataplan/pg';
+import { context as grafastContext, lambda, object } from 'grafast';
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+function hasI18nTag(codec) {
+    const tags = codec.extensions?.tags;
+    if (!tags)
+        return false;
+    const val = tags.i18n;
+    if (typeof val === 'string' && val.length > 0)
+        return val;
+    return false;
+}
+function resolvePgTypeName(codec) {
+    if (codec === TYPES.uuid)
+        return 'uuid';
+    if (codec === TYPES.int)
+        return 'int4';
+    if (codec === TYPES.bigint)
+        return 'int8';
+    if (codec === TYPES.text)
+        return 'text';
+    if (codec === TYPES.varchar)
+        return 'text';
+    return codec?.name ?? 'text';
+}
+function resolveAttrPgType(codec) {
+    if (codec === TYPES.text)
+        return 'text';
+    if (codec === TYPES.varchar)
+        return 'text';
+    if (codec?.name === 'citext')
+        return 'citext';
+    return codec?.name ?? 'text';
+}
+// ─── Plugin Factory ──────────────────────────────────────────────────────────
+export function createI18nPlugin(options = {}) {
+    const { langCodeColumn = 'lang_code', langCodeGqlField = 'langCode', allowedTypes = ['text', 'citext'], defaultLanguages = ['en'], } = options;
+    // Closure-scoped state shared between init and field hooks
+    let i18nRegistry = {};
+    const localeTypeCache = {};
+    return {
+        name: 'I18nPlugin',
+        version: '1.0.0',
+        schema: {
+            hooks: {
+                init: {
+                    callback(_, build) {
+                        i18nRegistry = {};
+                        for (const [, codec] of Object.entries(build.input.pgRegistry.pgCodecs)) {
+                            const c = codec;
+                            if (!c.attributes)
+                                continue;
+                            const translationTableName = hasI18nTag(c);
+                            if (!translationTableName)
+                                continue;
+                            // Get schema name from the codec's pg extensions
+                            let schemaName = c.extensions?.pg?.schemaName ?? 'public';
+                            let pkColumn = null;
+                            let pkType = 'text';
+                            for (const [, resource] of Object.entries(build.input.pgRegistry.pgResources)) {
+                                const r = resource;
+                                if (r.codec === c) {
+                                    // Try multiple sources for schema name
+                                    const rSchema = r.extensions?.pg?.schemaName ?? r.schemaName;
+                                    if (rSchema)
+                                        schemaName = rSchema;
+                                    // Extract PK from the resource's uniques array
+                                    const uniques = r.uniques;
+                                    if (uniques) {
+                                        const pk = uniques.find((u) => u.isPrimary);
+                                        if (pk && pk.attributes.length === 1) {
+                                            pkColumn = pk.attributes[0];
+                                            const pkAttr = c.attributes[pkColumn];
+                                            if (pkAttr) {
+                                                pkType = resolvePgTypeName(pkAttr.codec);
+                                            }
+                                        }
+                                    }
+                                    break;
+                                }
+                            }
+                            if (!pkColumn)
+                                continue;
+                            // Find the translation codec. The @i18n tag value is the SQL table name
+                            // (e.g. 'posts_translations'), but PostGraphile inflects codec names
+                            // to camelCase (e.g. 'postsTranslations'). Match via resource name.
+                            let translationCodec = null;
+                            for (const [, resource] of Object.entries(build.input.pgRegistry.pgResources)) {
+                                const r = resource;
+                                if (!r.codec?.attributes)
+                                    continue;
+                                // Match by the resource's SQL name (which preserves snake_case)
+                                const sqlName = r.codec?.extensions?.pg?.name ?? r.name;
+                                if (sqlName === translationTableName) {
+                                    translationCodec = r.codec;
+                                    break;
+                                }
+                            }
+                            // Fallback: try matching the inflected codec name directly
+                            if (!translationCodec) {
+                                const inflectedName = build.inflection.camelCase(translationTableName);
+                                for (const [, tCodec] of Object.entries(build.input.pgRegistry.pgCodecs)) {
+                                    const tc = tCodec;
+                                    if (!tc.attributes)
+                                        continue;
+                                    if (tc.name === translationTableName || tc.name === inflectedName) {
+                                        translationCodec = tc;
+                                        break;
+                                    }
+                                }
+                            }
+                            if (!translationCodec)
+                                continue;
+                            // Find FK column on translation table — convention first, then type match
+                            let fkColumn = null;
+                            const conventionalFk = `${c.name}_id`;
+                            if (translationCodec.attributes[conventionalFk]) {
+                                fkColumn = conventionalFk;
+                            }
+                            if (!fkColumn) {
+                                // Fallback: find a column with the same type as the PK, excluding
+                                // common non-FK columns (id, lang_code)
+                                for (const [attrName, attr] of Object.entries(translationCodec.attributes)) {
+                                    if (attrName === 'id' || attrName === langCodeColumn)
+                                        continue;
+                                    const a = attr;
+                                    if (a.codec === c.attributes[pkColumn].codec) {
+                                        fkColumn = attrName;
+                                        break;
+                                    }
+                                }
+                            }
+                            if (!fkColumn)
+                                continue;
+                            // Discover translatable fields
+                            const fields = {};
+                            for (const [attrName, attr] of Object.entries(translationCodec.attributes)) {
+                                if (attrName === langCodeColumn || attrName === fkColumn)
+                                    continue;
+                                if (attrName === 'id' || attrName === 'created_at' || attrName === 'updated_at')
+                                    continue;
+                                const pgType = resolveAttrPgType(attr.codec);
+                                if (!allowedTypes.includes(pgType))
+                                    continue;
+                                const gqlName = build.inflection.camelCase(attrName);
+                                fields[gqlName] = {
+                                    column: attrName,
+                                    type: pgType,
+                                    isNotNull: !!attr.notNull,
+                                };
+                            }
+                            if (Object.keys(fields).length === 0)
+                                continue;
+                            i18nRegistry[c.name] = {
+                                baseTable: c.name,
+                                translationTable: translationTableName,
+                                schemaName,
+                                fkColumn,
+                                pkColumn,
+                                pkType,
+                                fields,
+                            };
+                        }
+                        return _;
+                    },
+                },
+                GraphQLObjectType_fields(fields, build, context) {
+                    const { graphql: { GraphQLString, GraphQLObjectType, GraphQLNonNull } } = build;
+                    const { scope } = context;
+                    if (!scope.pgCodec || !scope.isPgClassType)
+                        return fields;
+                    const codec = scope.pgCodec;
+                    const info = i18nRegistry[codec.name];
+                    if (!info)
+                        return fields;
+                    const localeFieldsConfig = {
+                        [langCodeGqlField]: { type: GraphQLString },
                     };
-                    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 } } = 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;
-        if (!identifier || !idType) {
-            return fields;
-        }
-        const { key, fields: i18nFields } = i18nTable;
-        const localeFieldName = 'localeStrings';
-        const localeFieldsConfig = 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
-            }
-        });
-        const localeFieldsType = new GraphQLObjectType({
-            name: `${context.Self.name}LocaleStrings`,
-            description: `Locales for ${context.Self.name}`,
-            fields: localeFieldsConfig
-        });
-        return build.extend(fields, {
-            [localeFieldName]: fieldWithHooks(localeFieldName, (fieldContext) => {
-                const { addDataGenerator } = fieldContext;
-                addDataGenerator(() => ({
-                    pgQuery: (queryBuilder) => {
-                        queryBuilder.select(build.pgSql.fragment `${queryBuilder.getTableAlias()}.${build.pgSql.identifier(identifier)}`, identifier);
+                    for (const [gqlName, field] of Object.entries(info.fields)) {
+                        localeFieldsConfig[gqlName] = {
+                            type: field.isNotNull ? new GraphQLNonNull(GraphQLString) : GraphQLString,
+                        };
                     }
-                }));
-                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(source, _args, gqlContext) {
-                        const languageCodes = gqlContext.langCodes ?? langPluginDefaultLanguages;
-                        const getLoader = gqlContext.getLanguageDataLoader ??
-                            defaultLanguageLoaderFactory;
-                        const dataloader = getLoader(props, gqlContext.pgClient, languageCodes, identifier, idType, langPluginLanguageCodeColumn, langPluginLanguageCodeGqlField);
-                        return dataloader.load(source.id);
+                    const localeTypeName = `${build.inflection.tableType(codec)}LocaleStrings`;
+                    if (!localeTypeCache[localeTypeName]) {
+                        localeTypeCache[localeTypeName] = new GraphQLObjectType({
+                            name: localeTypeName,
+                            fields: localeFieldsConfig,
+                        });
                     }
-                };
-            }, 'Adding the language code field from the lang plugin')
-        });
-    });
-};
-export { additionalGraphQLContextFromRequest, makeLanguageDataLoaderForTable } from './middleware';
-export default LangPlugin;
+                    const localeType = localeTypeCache[localeTypeName];
+                    const { schemaName, baseTable, translationTable, fkColumn, pkColumn, pkType, fields: i18nFields } = info;
+                    const coalescedCols = Object.values(i18nFields)
+                        .map(f => `coalesce(v."${f.column}", b."${f.column}") as "${f.column}"`)
+                        .join(', ');
+                    // Build the SQL query template
+                    const sqlQuery = `SELECT v."${langCodeColumn}" AS "lang_code", ${coalescedCols}
+             FROM "${schemaName}"."${baseTable}" b
+             LEFT JOIN "${schemaName}"."${translationTable}" v
+               ON v."${fkColumn}" = b."${pkColumn}"
+               AND array_position($2::text[], v."${langCodeColumn}") IS NOT NULL
+             WHERE b."${pkColumn}" = $1::${pkType}
+             ORDER BY array_position($2::text[], v."${langCodeColumn}") ASC NULLS LAST
+             LIMIT 1`;
+                    // Build column names list for mapping base values
+                    const baseColNames = Object.entries(i18nFields).map(([gqlName, f]) => ({
+                        gqlName,
+                        column: f.column,
+                    }));
+                    return build.extend(fields, {
+                        localeStrings: {
+                            type: new GraphQLNonNull(localeType),
+                            plan($parent) {
+                                // Extract PK and all base translatable columns from the parent row
+                                const $id = $parent.get(pkColumn);
+                                const $baseCols = {};
+                                for (const { column } of baseColNames) {
+                                    $baseCols[column] = $parent.get(column);
+                                }
+                                const $withPgClient = grafastContext().get('withPgClient');
+                                const $langCodes = grafastContext().get('langCodes');
+                                // Combine all inputs into a single step
+                                const $input = object({
+                                    id: $id,
+                                    withPgClient: $withPgClient,
+                                    langCodes: $langCodes,
+                                    ...$baseCols,
+                                });
+                                return lambda($input, async (input) => {
+                                    const { id, withPgClient, langCodes: ctxLangCodes, ...baseCols } = input;
+                                    const langs = ctxLangCodes ?? defaultLanguages;
+                                    if (!withPgClient || !id) {
+                                        const result = { [langCodeGqlField]: null };
+                                        for (const { gqlName, column } of baseColNames) {
+                                            result[gqlName] = baseCols[column] ?? null;
+                                        }
+                                        return result;
+                                    }
+                                    const row = await withPgClient(null, async (client) => {
+                                        const { rows } = await client.query(sqlQuery, [id, langs]);
+                                        return rows[0] ?? null;
+                                    });
+                                    if (!row) {
+                                        const result = { [langCodeGqlField]: null };
+                                        for (const { gqlName, column } of baseColNames) {
+                                            result[gqlName] = baseCols[column] ?? null;
+                                        }
+                                        return result;
+                                    }
+                                    const result = { [langCodeGqlField]: row.lang_code };
+                                    for (const { gqlName, column } of baseColNames) {
+                                        result[gqlName] = row[column] ?? null;
+                                    }
+                                    return result;
+                                });
+                            },
+                        },
+                    }, 'Adding i18n localeStrings field');
+                },
+            },
+        },
+    };
+}
+export const I18nPlugin = createI18nPlugin();

package/esm/preset.d.ts

@@ -0,0 +1,34 @@
+/**
+ * PostGraphile v5 i18n Preset
+ *
+ * Convenience preset that bundles the i18n plugin with configurable options.
+ *
+ * @example
+ * ```typescript
+ * import { I18nPreset } from 'graphile-i18n';
+ *
+ * const preset = {
+ *   extends: [
+ *     I18nPreset(),
+ *   ],
+ * };
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { I18nPreset } from 'graphile-i18n';
+ *
+ * const preset = {
+ *   extends: [
+ *     I18nPreset({
+ *       defaultLanguages: ['en', 'es'],
+ *       langCodeColumn: 'lang_code',
+ *     }),
+ *   ],
+ * };
+ * ```
+ */
+import type { GraphileConfig } from 'graphile-config';
+import type { I18nPluginOptions } from './types';
+export declare function I18nPreset(options?: I18nPluginOptions): GraphileConfig.Preset;
+export default I18nPreset;

package/esm/preset.js

@@ -0,0 +1,37 @@
+/**
+ * PostGraphile v5 i18n Preset
+ *
+ * Convenience preset that bundles the i18n plugin with configurable options.
+ *
+ * @example
+ * ```typescript
+ * import { I18nPreset } from 'graphile-i18n';
+ *
+ * const preset = {
+ *   extends: [
+ *     I18nPreset(),
+ *   ],
+ * };
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { I18nPreset } from 'graphile-i18n';
+ *
+ * const preset = {
+ *   extends: [
+ *     I18nPreset({
+ *       defaultLanguages: ['en', 'es'],
+ *       langCodeColumn: 'lang_code',
+ *     }),
+ *   ],
+ * };
+ * ```
+ */
+import { createI18nPlugin } from './plugin';
+export function I18nPreset(options = {}) {
+    return {
+        plugins: [createI18nPlugin(options)],
+    };
+}
+export default I18nPreset;

package/esm/types.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Types for the graphile-i18n v5 plugin.
+ */
+export interface I18nPluginOptions {
+    /**
+     * Column name on the translation table that stores the language code.
+     * @default 'lang_code'
+     */
+    langCodeColumn?: string;
+    /**
+     * GraphQL field name for the language code in the locale object.
+     * @default 'langCode'
+     */
+    langCodeGqlField?: string;
+    /**
+     * Column types eligible for translation overlay.
+     * @default ['text', 'citext']
+     */
+    allowedTypes?: string[];
+    /**
+     * Fallback language codes when no Accept-Language header is provided.
+     * @default ['en']
+     */
+    defaultLanguages?: string[];
+}
+export interface I18nTableInfo {
+    /** Base table name */
+    baseTable: string;
+    /** Translation table name */
+    translationTable: string;
+    /** Schema name */
+    schemaName: string;
+    /** FK column on the translation table referencing the base table PK */
+    fkColumn: string;
+    /** Base table PK column name */
+    pkColumn: string;
+    /** Base table PK PostgreSQL type */
+    pkType: string;
+    /** Translatable field mappings: { gqlFieldName: { column, type, isNotNull } } */
+    fields: Record<string, TranslatableField>;
+}
+export interface TranslatableField {
+    column: string;
+    type: string;
+    isNotNull: boolean;
+}

package/esm/types.js

@@ -0,0 +1,4 @@
+/**
+ * Types for the graphile-i18n v5 plugin.
+ */
+export {};

package/index.d.ts

@@ -1,5 +1,37 @@
-import LangPlugin from './plugin';
-export { LangPlugin, type LangPluginOptions } from './plugin';
-export { additionalGraphQLContextFromRequest, makeLanguageDataLoaderForTable, type I18nGraphQLContext, type I18nRequestLike, type LanguageDataLoaderFactory } from './middleware';
-export { env } from './env';
-export default LangPlugin;
+/**
+ * graphile-i18n — PostGraphile v5 i18n Plugin
+ *
+ * Language-aware fields sourced from @i18n translation tables
+ * with Accept-Language negotiation and configurable fallback chains.
+ *
+ * @example
+ * ```typescript
+ * import { I18nPreset } from 'graphile-i18n';
+ *
+ * const preset = {
+ *   extends: [
+ *     I18nPreset(),
+ *   ],
+ * };
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { I18nPreset } from 'graphile-i18n';
+ *
+ * const preset = {
+ *   extends: [
+ *     I18nPreset({
+ *       defaultLanguages: ['en', 'es'],
+ *       langCodeColumn: 'lang_code',
+ *       allowedTypes: ['text', 'citext'],
+ *     }),
+ *   ],
+ * };
+ * ```
+ */
+export { createI18nPlugin, I18nPlugin } from './plugin';
+export { I18nPreset } from './preset';
+export { makeI18nContext, additionalGraphQLContextFromRequest } from './middleware';
+export type { I18nPluginOptions, I18nTableInfo, TranslatableField } from './types';
+export type { I18nMiddlewareOptions } from './middleware';

package/index.js

@@ -1,15 +1,46 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+/**
+ * graphile-i18n — PostGraphile v5 i18n Plugin
+ *
+ * Language-aware fields sourced from @i18n translation tables
+ * with Accept-Language negotiation and configurable fallback chains.
+ *
+ * @example
+ * ```typescript
+ * import { I18nPreset } from 'graphile-i18n';
+ *
+ * const preset = {
+ *   extends: [
+ *     I18nPreset(),
+ *   ],
+ * };
+ * ```
+ *
+ * @example
+ * ```typescript
+ * import { I18nPreset } from 'graphile-i18n';
+ *
+ * const preset = {
+ *   extends: [
+ *     I18nPreset({
+ *       defaultLanguages: ['en', 'es'],
+ *       langCodeColumn: 'lang_code',
+ *       allowedTypes: ['text', 'citext'],
+ *     }),
+ *   ],
+ * };
+ * ```
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.env = exports.makeLanguageDataLoaderForTable = exports.additionalGraphQLContextFromRequest = exports.LangPlugin = void 0;
-const plugin_1 = __importDefault(require("./plugin"));
-var plugin_2 = require("./plugin");
-Object.defineProperty(exports, "LangPlugin", { enumerable: true, get: function () { return plugin_2.LangPlugin; } });
+exports.additionalGraphQLContextFromRequest = exports.makeI18nContext = exports.I18nPreset = exports.I18nPlugin = exports.createI18nPlugin = void 0;
+// Plugin
+var plugin_1 = require("./plugin");
+Object.defineProperty(exports, "createI18nPlugin", { enumerable: true, get: function () { return plugin_1.createI18nPlugin; } });
+Object.defineProperty(exports, "I18nPlugin", { enumerable: true, get: function () { return plugin_1.I18nPlugin; } });
+// Preset
+var preset_1 = require("./preset");
+Object.defineProperty(exports, "I18nPreset", { enumerable: true, get: function () { return preset_1.I18nPreset; } });
+// Middleware
 var middleware_1 = require("./middleware");
+Object.defineProperty(exports, "makeI18nContext", { enumerable: true, get: function () { return middleware_1.makeI18nContext; } });
 Object.defineProperty(exports, "additionalGraphQLContextFromRequest", { enumerable: true, get: function () { return middleware_1.additionalGraphQLContextFromRequest; } });
-Object.defineProperty(exports, "makeLanguageDataLoaderForTable", { enumerable: true, get: function () { return middleware_1.makeLanguageDataLoaderForTable; } });
-var env_1 = require("./env");
-Object.defineProperty(exports, "env", { enumerable: true, get: function () { return env_1.env; } });
-exports.default = plugin_1.default;