graphile-ltree 1.1.0

package/esm/plugins/ltree-codec.js

@@ -0,0 +1,121 @@
+/**
+ * LtreeCodecPlugin
+ *
+ * Ensures PostGraphile v5 properly handles ltree, lquery, and ltxtquery types.
+ *
+ * PostGraphile v5 (rc.8+) natively maps ltree to a GraphQL scalar named "LTree".
+ * This plugin:
+ * 1. Falls back to registering codecs if PostGraphile's native handling misses them
+ * 2. Re-enables ltree columns for select/filterBy (overrides rc.8 HIDE_BY_DEFAULT)
+ *
+ * The native scalar name is "LTree" (capital T). All operators and downstream
+ * plugins should reference LTREE_SCALAR_NAME for consistency.
+ */
+import { GraphQLString } from 'graphql';
+import sql from 'pg-sql2';
+export const LTREE_SCALAR_NAME = 'LTree';
+export const LtreeCodecPlugin = {
+    name: 'LtreeCodecPlugin',
+    version: '1.0.0',
+    description: 'Ensures ltree/lquery codecs are properly registered and enabled',
+    gather: {
+        hooks: {
+            async pgCodecs_findPgCodec(info, event) {
+                if (event.pgCodec)
+                    return;
+                const { pgType: type, serviceName } = event;
+                const isLtree = type.typname === 'ltree';
+                const isLquery = type.typname === 'lquery';
+                const isLtxtquery = type.typname === 'ltxtquery';
+                if (!isLtree && !isLquery && !isLtxtquery)
+                    return;
+                const ns = await info.helpers.pgIntrospection.getNamespace(serviceName, type.typnamespace);
+                const schemaName = ns?.nspname || 'pg_catalog';
+                event.pgCodec = {
+                    name: type.typname,
+                    sqlType: sql.identifier(schemaName, type.typname),
+                    fromPg: (value) => value,
+                    toPg: (value) => value,
+                    attributes: undefined,
+                    executor: null,
+                    extensions: {
+                        oid: type._id,
+                        pg: {
+                            serviceName,
+                            schemaName,
+                            name: type.typname
+                        }
+                    }
+                };
+            }
+        }
+    },
+    schema: {
+        hooks: {
+            init: {
+                before: ['PgCodecs', 'PgConnectionArgFilterPlugin'],
+                callback(_, build) {
+                    const { setGraphQLTypeForPgCodec, hasGraphQLTypeForPgCodec } = build;
+                    for (const codec of Object.values(build.input.pgRegistry.pgCodecs)) {
+                        if (codec.name === 'ltree') {
+                            if (!hasGraphQLTypeForPgCodec(codec, 'input')) {
+                                build.registerScalarType(LTREE_SCALAR_NAME, {}, () => ({
+                                    description: 'A PostgreSQL ltree hierarchical label path, represented as a dot-delimited string (e.g. "projects.alpha.docs").',
+                                    serialize(value) {
+                                        return String(value);
+                                    },
+                                    parseValue(value) {
+                                        if (typeof value === 'string')
+                                            return value;
+                                        throw new Error(`${LTREE_SCALAR_NAME} must be a string`);
+                                    },
+                                    parseLiteral(lit) {
+                                        if (lit.kind === 'NullValue')
+                                            return null;
+                                        if (lit.kind !== 'StringValue') {
+                                            throw new Error(`${LTREE_SCALAR_NAME} must be a string`);
+                                        }
+                                        return lit.value;
+                                    }
+                                }), `LtreeCodecPlugin registering ${LTREE_SCALAR_NAME} scalar`);
+                                setGraphQLTypeForPgCodec(codec, 'input', LTREE_SCALAR_NAME);
+                                setGraphQLTypeForPgCodec(codec, 'output', LTREE_SCALAR_NAME);
+                            }
+                        }
+                        else if (codec.name === 'lquery' || codec.name === 'ltxtquery') {
+                            if (!hasGraphQLTypeForPgCodec(codec, 'input')) {
+                                setGraphQLTypeForPgCodec(codec, 'input', GraphQLString.name);
+                            }
+                            if (!hasGraphQLTypeForPgCodec(codec, 'output')) {
+                                setGraphQLTypeForPgCodec(codec, 'output', GraphQLString.name);
+                            }
+                        }
+                    }
+                    return _;
+                }
+            }
+        },
+        entityBehavior: {
+            pgCodecAttribute: {
+                inferred: {
+                    after: ['default'],
+                    provides: ['ltreeCodecPlugin'],
+                    callback(behavior, [codec, attributeName]) {
+                        const attr = codec.attributes?.[attributeName];
+                        const attrCodec = attr?.codec;
+                        const isLtree = attrCodec?.name === 'ltree' ||
+                            attrCodec?.extensions?.pg?.name === 'ltree';
+                        if (!isLtree)
+                            return behavior;
+                        return [
+                            behavior,
+                            'attribute:select',
+                            'attribute:base',
+                            'condition:attribute:filterBy'
+                        ];
+                    }
+                }
+            }
+        }
+    }
+};

package/esm/preset.d.ts

@@ -0,0 +1,28 @@
+import type { GraphileConfig } from 'graphile-config';
+/**
+ * GraphileLtreePreset
+ *
+ * Base preset: ltree codec, detection, and raw ltree operators.
+ *
+ * Operators on LTree fields: isAncestorOf, isDescendantOf, matchesGlob
+ * (accept dot-delimited or slash-delimited paths)
+ */
+export declare const GraphileLtreePreset: GraphileConfig.Preset;
+/**
+ * GraphileFolderPreset
+ *
+ * Folder-oriented layer on top of the base ltree preset.
+ *
+ * Adds:
+ * - Virtual `{column}Folder` fields with slash-delimited paths
+ * - Folder operators: within, ancestorOf, glob (always slash-delimited)
+ *
+ * @example
+ * ```graphql
+ * allFiles(where: { path: { within: "/projects/alpha" } }) {
+ *   nodes { pathFolder filename }
+ * }
+ * ```
+ */
+export declare const GraphileFolderPreset: GraphileConfig.Preset;
+export default GraphileFolderPreset;

package/esm/preset.js

@@ -0,0 +1,52 @@
+import { createLtreeOperatorFactory } from './plugins/connection-filter-operators';
+import { LtreeExtensionDetectionPlugin } from './plugins/detect-ltree';
+import { LtreeFolderFieldPlugin } from './plugins/folder-field';
+import { createFolderOperatorFactory } from './plugins/folder-filter-operators';
+import { LtreeCodecPlugin } from './plugins/ltree-codec';
+/**
+ * GraphileLtreePreset
+ *
+ * Base preset: ltree codec, detection, and raw ltree operators.
+ *
+ * Operators on LTree fields: isAncestorOf, isDescendantOf, matchesGlob
+ * (accept dot-delimited or slash-delimited paths)
+ */
+export const GraphileLtreePreset = {
+    plugins: [
+        LtreeExtensionDetectionPlugin,
+        LtreeCodecPlugin
+    ],
+    schema: {
+        connectionFilterOperatorFactories: [
+            createLtreeOperatorFactory()
+        ]
+    }
+};
+/**
+ * GraphileFolderPreset
+ *
+ * Folder-oriented layer on top of the base ltree preset.
+ *
+ * Adds:
+ * - Virtual `{column}Folder` fields with slash-delimited paths
+ * - Folder operators: within, ancestorOf, glob (always slash-delimited)
+ *
+ * @example
+ * ```graphql
+ * allFiles(where: { path: { within: "/projects/alpha" } }) {
+ *   nodes { pathFolder filename }
+ * }
+ * ```
+ */
+export const GraphileFolderPreset = {
+    extends: [GraphileLtreePreset],
+    plugins: [
+        LtreeFolderFieldPlugin
+    ],
+    schema: {
+        connectionFilterOperatorFactories: [
+            createFolderOperatorFactory()
+        ]
+    }
+};
+export default GraphileFolderPreset;

package/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * graphile-ltree — PostGraphile v5 ltree Plugin
+ *
+ * Two presets:
+ *
+ * - `GraphileLtreePreset` — base ltree operators (isAncestorOf, isDescendantOf, matchesGlob)
+ * - `GraphileFolderPreset` — folder-oriented layer (within, ancestorOf, glob) + pathFolder fields
+ *
+ * @example
+ * ```typescript
+ * // For folder-style interface (recommended):
+ * import { GraphileFolderPreset } from 'graphile-ltree';
+ *
+ * // For raw ltree operators only:
+ * import { GraphileLtreePreset } from 'graphile-ltree';
+ * ```
+ */
+export { GraphileFolderPreset, GraphileLtreePreset } from './preset';
+export type { LtreeExtensionInfo } from './plugins/detect-ltree';
+export { LtreeExtensionDetectionPlugin } from './plugins/detect-ltree';
+export { LtreeFolderFieldPlugin } from './plugins/folder-field';
+export { LTREE_SCALAR_NAME, LtreeCodecPlugin } from './plugins/ltree-codec';
+export { createLtreeOperatorFactory } from './plugins/connection-filter-operators';
+export { createFolderOperatorFactory } from './plugins/folder-filter-operators';

package/index.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * graphile-ltree — PostGraphile v5 ltree Plugin
+ *
+ * Two presets:
+ *
+ * - `GraphileLtreePreset` — base ltree operators (isAncestorOf, isDescendantOf, matchesGlob)
+ * - `GraphileFolderPreset` — folder-oriented layer (within, ancestorOf, glob) + pathFolder fields
+ *
+ * @example
+ * ```typescript
+ * // For folder-style interface (recommended):
+ * import { GraphileFolderPreset } from 'graphile-ltree';
+ *
+ * // For raw ltree operators only:
+ * import { GraphileLtreePreset } from 'graphile-ltree';
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFolderOperatorFactory = exports.createLtreeOperatorFactory = exports.LtreeCodecPlugin = exports.LTREE_SCALAR_NAME = exports.LtreeFolderFieldPlugin = exports.LtreeExtensionDetectionPlugin = exports.GraphileLtreePreset = exports.GraphileFolderPreset = void 0;
+// Presets
+var preset_1 = require("./preset");
+Object.defineProperty(exports, "GraphileFolderPreset", { enumerable: true, get: function () { return preset_1.GraphileFolderPreset; } });
+Object.defineProperty(exports, "GraphileLtreePreset", { enumerable: true, get: function () { return preset_1.GraphileLtreePreset; } });
+var detect_ltree_1 = require("./plugins/detect-ltree");
+Object.defineProperty(exports, "LtreeExtensionDetectionPlugin", { enumerable: true, get: function () { return detect_ltree_1.LtreeExtensionDetectionPlugin; } });
+var folder_field_1 = require("./plugins/folder-field");
+Object.defineProperty(exports, "LtreeFolderFieldPlugin", { enumerable: true, get: function () { return folder_field_1.LtreeFolderFieldPlugin; } });
+var ltree_codec_1 = require("./plugins/ltree-codec");
+Object.defineProperty(exports, "LTREE_SCALAR_NAME", { enumerable: true, get: function () { return ltree_codec_1.LTREE_SCALAR_NAME; } });
+Object.defineProperty(exports, "LtreeCodecPlugin", { enumerable: true, get: function () { return ltree_codec_1.LtreeCodecPlugin; } });
+// Connection filter operator factories
+var connection_filter_operators_1 = require("./plugins/connection-filter-operators");
+Object.defineProperty(exports, "createLtreeOperatorFactory", { enumerable: true, get: function () { return connection_filter_operators_1.createLtreeOperatorFactory; } });
+var folder_filter_operators_1 = require("./plugins/folder-filter-operators");
+Object.defineProperty(exports, "createFolderOperatorFactory", { enumerable: true, get: function () { return folder_filter_operators_1.createFolderOperatorFactory; } });

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "graphile-ltree",
+  "version": "1.1.0",
+  "description": "PostGraphile v5 ltree plugin — auto-detects ltree columns, exposes slash-path folder fields, and provides containment/glob filter operators",
+  "author": "Constructive <developers@constructive.io>",
+  "homepage": "https://github.com/constructive-io/constructive",
+  "license": "MIT",
+  "main": "index.js",
+  "module": "esm/index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "clean": "makage clean",
+    "prepack": "npm run build",
+    "build": "makage build",
+    "build:dev": "makage build --dev",
+    "lint": "eslint . --fix",
+    "test": "jest --forceExit",
+    "test:watch": "jest --watch"
+  },
+  "publishConfig": {
+    "access": "public",
+    "directory": "dist"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/constructive-io/constructive"
+  },
+  "bugs": {
+    "url": "https://github.com/constructive-io/constructive/issues"
+  },
+  "peerDependencies": {
+    "@dataplan/pg": "1.0.0",
+    "grafast": "1.0.0",
+    "graphile-build": "5.0.0",
+    "graphile-build-pg": "5.0.0",
+    "graphile-config": "1.0.0",
+    "graphile-connection-filter": "^1.5.6",
+    "graphql": "16.13.0",
+    "pg-sql2": "5.0.0",
+    "postgraphile": "5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "graphile-connection-filter": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^22.19.11",
+    "graphile-test": "^4.9.5",
+    "makage": "^0.3.0",
+    "pgsql-test": "^4.9.5"
+  },
+  "keywords": [
+    "postgraphile",
+    "graphile",
+    "constructive",
+    "plugin",
+    "postgres",
+    "graphql",
+    "ltree",
+    "hierarchy",
+    "path",
+    "folder",
+    "tree"
+  ],
+  "gitHead": "cbbd6c688fcda5a307461af50b06e994ab1f8ea4"
+}

package/plugins/connection-filter-operators.d.ts

@@ -0,0 +1,18 @@
+import 'graphile-build';
+import 'graphile-build-pg';
+import 'graphile-connection-filter';
+import type { ConnectionFilterOperatorFactory } from 'graphile-connection-filter';
+/**
+ * Creates the ltree connection filter operator factory.
+ *
+ * Registers operators on the LTree scalar type (only ltree columns):
+ *
+ * - `isAncestorOf`   -- column <@ to_path(value): finds descendants
+ * - `isDescendantOf` -- column @> to_path(value): finds ancestors
+ * - `matchesGlob`    -- column ~ to_query(value): glob/lquery pattern matching
+ *
+ * All operators accept dot-delimited paths or slash-delimited paths.
+ * When ltree_helpers is installed, conversion happens server-side via
+ * to_path() / to_query(). Otherwise, inline SQL casts are used.
+ */
+export declare function createLtreeOperatorFactory(): ConnectionFilterOperatorFactory;

package/plugins/connection-filter-operators.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLtreeOperatorFactory = createLtreeOperatorFactory;
+require("graphile-build");
+require("graphile-build-pg");
+require("graphile-connection-filter");
+const pg_sql2_1 = __importDefault(require("pg-sql2"));
+const ltree_codec_1 = require("./ltree-codec");
+function hasLtreeHelpers(build) {
+    const pgRegistry = build.input?.pgRegistry;
+    if (!pgRegistry)
+        return false;
+    for (const resource of Object.values(pgRegistry.pgResources)) {
+        const r = resource;
+        if (r?.extensions?.pg?.schemaName === 'ltree_helpers')
+            return true;
+    }
+    return false;
+}
+function toPathExpr(value, useHelpers) {
+    if (useHelpers) {
+        return pg_sql2_1.default.fragment `ltree_helpers.to_path(${value})`;
+    }
+    return pg_sql2_1.default.fragment `replace(ltrim(${value}, '/'), '/', '.')::ltree`;
+}
+function toQueryExpr(value, useHelpers) {
+    if (useHelpers) {
+        return pg_sql2_1.default.fragment `ltree_helpers.to_query(${value})`;
+    }
+    // Glob → lquery conversion:
+    //   ** → * (0+ labels in lquery)
+    //   *  → *{1} (exactly 1 label)
+    // We use a placeholder to avoid ** being affected by the * → *{1} step.
+    return pg_sql2_1.default.fragment `replace(replace(replace(replace(ltrim(${value}, '/'), '**', '__DSTAR__'), '*', '*{1}'), '__DSTAR__', '*'), '/', '.')::lquery`;
+}
+/**
+ * Creates the ltree connection filter operator factory.
+ *
+ * Registers operators on the LTree scalar type (only ltree columns):
+ *
+ * - `isAncestorOf`   -- column <@ to_path(value): finds descendants
+ * - `isDescendantOf` -- column @> to_path(value): finds ancestors
+ * - `matchesGlob`    -- column ~ to_query(value): glob/lquery pattern matching
+ *
+ * All operators accept dot-delimited paths or slash-delimited paths.
+ * When ltree_helpers is installed, conversion happens server-side via
+ * to_path() / to_query(). Otherwise, inline SQL casts are used.
+ */
+function createLtreeOperatorFactory() {
+    return (build) => {
+        const ltreeInfo = build.pgLtreeExtensionInfo;
+        if (!ltreeInfo)
+            return [];
+        const useHelpers = hasLtreeHelpers(build);
+        const registrations = [];
+        registrations.push({
+            typeNames: ltree_codec_1.LTREE_SCALAR_NAME,
+            operatorName: 'isAncestorOf',
+            spec: {
+                description: 'Is a descendant of (or equal to) the specified path. ' +
+                    'Returns rows whose ltree path is contained by the given path.',
+                resolveType: (fieldType) => fieldType,
+                resolveSqlValue: () => pg_sql2_1.default.null,
+                resolve(sqlIdentifier, _sqlValue, input, _$where, _details) {
+                    const pathVal = pg_sql2_1.default.value(String(input));
+                    return pg_sql2_1.default.fragment `${sqlIdentifier} <@ ${toPathExpr(pathVal, useHelpers)}`;
+                }
+            }
+        });
+        registrations.push({
+            typeNames: ltree_codec_1.LTREE_SCALAR_NAME,
+            operatorName: 'isDescendantOf',
+            spec: {
+                description: 'Is an ancestor of (or equal to) the specified path. ' +
+                    'Returns rows whose ltree path contains the given path.',
+                resolveType: (fieldType) => fieldType,
+                resolveSqlValue: () => pg_sql2_1.default.null,
+                resolve(sqlIdentifier, _sqlValue, input, _$where, _details) {
+                    const pathVal = pg_sql2_1.default.value(String(input));
+                    return pg_sql2_1.default.fragment `${sqlIdentifier} @> ${toPathExpr(pathVal, useHelpers)}`;
+                }
+            }
+        });
+        registrations.push({
+            typeNames: ltree_codec_1.LTREE_SCALAR_NAME,
+            operatorName: 'matchesGlob',
+            spec: {
+                description: 'Matches the specified glob pattern (lquery). ' +
+                    'Use * for single-level wildcard, ** for recursive descent.',
+                resolveType: (fieldType) => fieldType,
+                resolveSqlValue: () => pg_sql2_1.default.null,
+                resolve(sqlIdentifier, _sqlValue, input, _$where, _details) {
+                    const globVal = pg_sql2_1.default.value(String(input));
+                    return pg_sql2_1.default.fragment `${sqlIdentifier} ~ ${toQueryExpr(globVal, useHelpers)}`;
+                }
+            }
+        });
+        return registrations;
+    };
+}

package/plugins/detect-ltree.d.ts

@@ -0,0 +1,18 @@
+import 'graphile-build';
+import 'graphile-build-pg';
+import type { PgCodec } from '@dataplan/pg';
+import type { GraphileConfig } from 'graphile-config';
+export interface LtreeExtensionInfo {
+    ltreeCodec: PgCodec;
+    lqueryCodec: PgCodec | null;
+}
+/**
+ * LtreeExtensionDetectionPlugin
+ *
+ * Detects ltree presence in the database by searching for ltree/lquery
+ * codecs in the pgRegistry. Stores detected info on the build object
+ * for downstream plugins.
+ *
+ * Gracefully degrades if ltree is not installed.
+ */
+export declare const LtreeExtensionDetectionPlugin: GraphileConfig.Plugin;

package/plugins/detect-ltree.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LtreeExtensionDetectionPlugin = void 0;
+require("graphile-build");
+require("graphile-build-pg");
+function isLtreeCodec(codec) {
+    return (codec?.name === 'ltree' ||
+        codec?.extensions?.pg?.name === 'ltree');
+}
+function isLqueryCodec(codec) {
+    return (codec?.name === 'lquery' ||
+        codec?.extensions?.pg?.name === 'lquery');
+}
+/**
+ * LtreeExtensionDetectionPlugin
+ *
+ * Detects ltree presence in the database by searching for ltree/lquery
+ * codecs in the pgRegistry. Stores detected info on the build object
+ * for downstream plugins.
+ *
+ * Gracefully degrades if ltree is not installed.
+ */
+exports.LtreeExtensionDetectionPlugin = {
+    name: 'LtreeExtensionDetectionPlugin',
+    version: '1.0.0',
+    description: 'Detects ltree extension in the database',
+    schema: {
+        hooks: {
+            build(build) {
+                const pgRegistry = build.input?.pgRegistry;
+                if (!pgRegistry) {
+                    return build;
+                }
+                let ltreeCodec = null;
+                let lqueryCodec = null;
+                for (const codec of Object.values(pgRegistry.pgCodecs)) {
+                    if (isLtreeCodec(codec)) {
+                        ltreeCodec = codec;
+                    }
+                    else if (isLqueryCodec(codec)) {
+                        lqueryCodec = codec;
+                    }
+                }
+                if (!ltreeCodec) {
+                    return build;
+                }
+                const ltreeInfo = {
+                    ltreeCodec,
+                    lqueryCodec
+                };
+                return build.extend(build, { pgLtreeExtensionInfo: ltreeInfo }, 'LtreeExtensionDetectionPlugin adding ltree build state');
+            }
+        }
+    }
+};

package/plugins/folder-field.d.ts

@@ -0,0 +1,19 @@
+import 'graphile-build';
+import 'graphile-build-pg';
+import type { GraphileConfig } from 'graphile-config';
+/**
+ * LtreeFolderFieldPlugin
+ *
+ * For every ltree column on every table:
+ *
+ * 1. Renames the raw ltree field from `{column}` to `{column}Tree`
+ *    via the `@name` smart tag (e.g. `path` -> `pathTree`)
+ *
+ * 2. Adds a virtual field with the original name (`path`) that returns
+ *    the slash-delimited folder path.
+ *    (e.g. 'projects.alpha.docs' -> '/projects/alpha/docs')
+ *
+ * This gives users the clean field name for display while preserving
+ * the raw ltree field (with all filter operators) under `{column}Tree`.
+ */
+export declare const LtreeFolderFieldPlugin: GraphileConfig.Plugin;

package/plugins/folder-field.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LtreeFolderFieldPlugin = void 0;
+require("graphile-build");
+require("graphile-build-pg");
+const graphql_1 = require("graphql");
+/**
+ * LtreeFolderFieldPlugin
+ *
+ * For every ltree column on every table:
+ *
+ * 1. Renames the raw ltree field from `{column}` to `{column}Tree`
+ *    via the `@name` smart tag (e.g. `path` -> `pathTree`)
+ *
+ * 2. Adds a virtual field with the original name (`path`) that returns
+ *    the slash-delimited folder path.
+ *    (e.g. 'projects.alpha.docs' -> '/projects/alpha/docs')
+ *
+ * This gives users the clean field name for display while preserving
+ * the raw ltree field (with all filter operators) under `{column}Tree`.
+ */
+exports.LtreeFolderFieldPlugin = {
+    name: 'LtreeFolderFieldPlugin',
+    version: '1.0.0',
+    description: 'Renames ltree columns to {col}Tree and adds virtual {col} folder fields',
+    after: ['LtreeExtensionDetectionPlugin', 'LtreeCodecPlugin', 'PgAttributesPlugin'],
+    schema: {
+        hooks: {
+            /**
+             * Before fields are built, rename ltree attributes via the @name tag.
+             * This ensures PostGraphile's plan system correctly maps the renamed
+             * field to the underlying database column.
+             */
+            init(_, build) {
+                const ltreeInfo = build.pgLtreeExtensionInfo;
+                if (!ltreeInfo)
+                    return _;
+                const pgRegistry = build.input?.pgRegistry;
+                if (!pgRegistry)
+                    return _;
+                for (const resource of Object.values(pgRegistry.pgResources)) {
+                    const r = resource;
+                    const codec = r?.codec;
+                    if (!codec?.attributes)
+                        continue;
+                    for (const [attrName, attr] of Object.entries(codec.attributes)) {
+                        const attrCodec = attr?.codec;
+                        if (!attrCodec)
+                            continue;
+                        const isLtree = attrCodec.name === 'ltree' ||
+                            attrCodec.extensions?.pg?.name === 'ltree';
+                        if (!isLtree)
+                            continue;
+                        // Set @name tag to rename: path → path_tree
+                        // PostGraphile's _attributeName inflector reads this tag
+                        attr.extensions = attr.extensions || {};
+                        attr.extensions.tags = attr.extensions.tags || {};
+                        attr.extensions.tags.name = `${attrName}_tree`;
+                    }
+                }
+                return _;
+            },
+            GraphQLObjectType_fields(fields, build, context) {
+                const ltreeInfo = build.pgLtreeExtensionInfo;
+                if (!ltreeInfo)
+                    return fields;
+                const { scope: { isPgClassType, pgCodec: rawPgCodec }, fieldWithHooks } = context;
+                if (!isPgClassType || !rawPgCodec?.attributes)
+                    return fields;
+                const codec = rawPgCodec;
+                const { lambda } = build.grafast;
+                let newFields = fields;
+                for (const [attrName, attr] of Object.entries(codec.attributes)) {
+                    const attrCodec = attr?.codec;
+                    if (!attrCodec)
+                        continue;
+                    const isLtree = attrCodec.name === 'ltree' ||
+                        attrCodec.extensions?.pg?.name === 'ltree';
+                    if (!isLtree)
+                        continue;
+                    // The original column name becomes the folder field name
+                    const folderFieldName = build.inflection.camelCase(attrName);
+                    newFields = build.extend(newFields, {
+                        [folderFieldName]: fieldWithHooks({ fieldName: folderFieldName }, () => ({
+                            description: `Slash-delimited path derived from the \`${attrName}\` ltree column. Example: \`/projects/alpha/docs\``,
+                            type: graphql_1.GraphQLString,
+                            plan($row) {
+                                const $ltreeVal = $row.get(attrName);
+                                return lambda($ltreeVal, (val) => {
+                                    if (val == null)
+                                        return null;
+                                    const str = String(val);
+                                    if (str === '')
+                                        return '/';
+                                    return '/' + str.replace(/\./g, '/');
+                                });
+                            }
+                        }))
+                    }, `LtreeFolderFieldPlugin adding folder field '${folderFieldName}' for '${attrName}' on '${codec.name}'`);
+                }
+                return newFields;
+            }
+        }
+    }
+};