node-type-registry 0.11.0 → 0.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-type-registry",
-  "version": "0.11.0",
+  "version": "0.14.0",
   "description": "Node type definitions for the Constructive blueprint system. Single source of truth for all Authz*, Data*, Relation*, and View* node types.",
   "author": "Constructive <developers@constructive.io>",
   "main": "index.js",
@@ -27,7 +27,6 @@
     "lint": "eslint . --fix",
     "test": "jest",
     "test:watch": "jest --watch",
-    "generate:seed": "ts-node src/codegen/generate-seed.ts",
     "generate:types": "ts-node src/codegen/generate-types.ts"
   },
   "dependencies": {
@@ -48,5 +47,5 @@
     "registry",
     "graphile"
   ],
-  "gitHead": "ec793fd5de36264f5c9738732657522c1d783a6d"
+  "gitHead": "1b3af3c5189b9ca2e765b9239a4b287099e64a03"
 }

package/relation/index.d.ts

@@ -2,3 +2,4 @@ export { RelationBelongsTo } from './relation-belongs-to';
 export { RelationHasOne } from './relation-has-one';
 export { RelationHasMany } from './relation-has-many';
 export { RelationManyToMany } from './relation-many-to-many';
+export { RelationSpatial } from './relation-spatial';

package/relation/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RelationManyToMany = exports.RelationHasMany = exports.RelationHasOne = exports.RelationBelongsTo = void 0;
+exports.RelationSpatial = exports.RelationManyToMany = exports.RelationHasMany = exports.RelationHasOne = exports.RelationBelongsTo = void 0;
 var relation_belongs_to_1 = require("./relation-belongs-to");
 Object.defineProperty(exports, "RelationBelongsTo", { enumerable: true, get: function () { return relation_belongs_to_1.RelationBelongsTo; } });
 var relation_has_one_1 = require("./relation-has-one");
@@ -9,3 +9,5 @@ var relation_has_many_1 = require("./relation-has-many");
 Object.defineProperty(exports, "RelationHasMany", { enumerable: true, get: function () { return relation_has_many_1.RelationHasMany; } });
 var relation_many_to_many_1 = require("./relation-many-to-many");
 Object.defineProperty(exports, "RelationManyToMany", { enumerable: true, get: function () { return relation_many_to_many_1.RelationManyToMany; } });
+var relation_spatial_1 = require("./relation-spatial");
+Object.defineProperty(exports, "RelationSpatial", { enumerable: true, get: function () { return relation_spatial_1.RelationSpatial; } });

package/relation/relation-spatial.d.ts

@@ -0,0 +1,2 @@
+import type { NodeTypeDefinition } from '../types';
+export declare const RelationSpatial: NodeTypeDefinition;

package/relation/relation-spatial.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationSpatial = void 0;
+exports.RelationSpatial = {
+    "name": "RelationSpatial",
+    "slug": "relation_spatial",
+    "category": "relation",
+    "display_name": "Spatial Relation",
+    "description": "Declares a spatial predicate between two existing geometry/geography columns. Inserts a metaschema_public.spatial_relation row; the sync_spatial_relation_tags trigger then projects a @spatialRelation smart tag onto the owner column so graphile-postgis' PostgisSpatialRelationsPlugin can expose it as a cross-table filter in GraphQL. Metadata-only: both source_field and target_field must already exist on their tables. Idempotent on (source_table_id, name). One direction per tag — author two RelationSpatial entries if symmetry is desired.",
+    "parameter_schema": {
+        "type": "object",
+        "properties": {
+            "source_table_id": {
+                "type": "string",
+                "format": "uuid",
+                "description": "Table that owns the relation (the @spatialRelation tag is emitted on the owner column of this table)"
+            },
+            "source_field_id": {
+                "type": "string",
+                "format": "uuid",
+                "description": "Geometry/geography column on source_table that carries the @spatialRelation smart tag"
+            },
+            "target_table_id": {
+                "type": "string",
+                "format": "uuid",
+                "description": "Table being referenced by the spatial predicate"
+            },
+            "target_field_id": {
+                "type": "string",
+                "format": "uuid",
+                "description": "Geometry/geography column on target_table that the predicate is evaluated against"
+            },
+            "name": {
+                "type": "string",
+                "description": "Relation name (stable, snake_case). Becomes the generated filter field name in GraphQL (e.g. nearby_clinic). Unique per (source_table_id, name) — idempotency key."
+            },
+            "operator": {
+                "type": "string",
+                "enum": [
+                    "st_contains",
+                    "st_within",
+                    "st_intersects",
+                    "st_covers",
+                    "st_coveredby",
+                    "st_overlaps",
+                    "st_touches",
+                    "st_dwithin"
+                ],
+                "description": "PostGIS spatial predicate. One of the 8 whitelisted operators. st_dwithin requires param_name."
+            },
+            "param_name": {
+                "type": "string",
+                "description": "Parameter name for parametric operators (currently only st_dwithin, which needs a distance argument). Must be NULL for all other operators. Enforced by table CHECK."
+            }
+        },
+        "required": [
+            "source_table_id",
+            "source_field_id",
+            "target_table_id",
+            "target_field_id",
+            "name",
+            "operator"
+        ]
+    },
+    "tags": [
+        "relation",
+        "spatial",
+        "postgis",
+        "schema"
+    ]
+};

package/codegen/generate-seed.d.ts

@@ -1,32 +0,0 @@
-/**
- * Generate SQL seed scripts from TypeScript node type definitions.
- *
- * Uses pgsql-deparser to produce individual INSERT statements per node type,
- * suitable for use as separate pgpm migration files.
- *
- * Usage:
- *   npx ts-node src/codegen/generate-seed.ts [--outdir <dir>] [--single] [--pgpm <dir>]
- *
- *   --outdir <dir>   Directory to write individual SQL files (default: stdout)
- *   --single         Emit a single combined seed.sql instead of per-node files
- *   --pgpm <dir>     Generate deploy/revert/verify files in pgpm package layout.
- *                     <dir> is the pgpm package root (e.g. packages/metaschema).
- *                     Files are written relative to this root at:
- *                       deploy/schemas/metaschema_public/tables/node_type_registry/data/seed.sql
- *                       revert/schemas/metaschema_public/tables/node_type_registry/data/seed.sql
- *                       verify/schemas/metaschema_public/tables/node_type_registry/data/seed.sql
- *
- * Examples:
- *   # Print all INSERT statements to stdout
- *   npx ts-node src/codegen/generate-seed.ts
- *
- *   # Generate individual migration files
- *   npx ts-node src/codegen/generate-seed.ts --outdir ./deploy/seed
- *
- *   # Generate a single combined seed file
- *   npx ts-node src/codegen/generate-seed.ts --single --outdir ./deploy
- *
- *   # Generate pgpm deploy/revert/verify files
- *   npx ts-node src/codegen/generate-seed.ts --pgpm ../../constructive-db/packages/metaschema
- */
-export {};

package/codegen/generate-seed.js

@@ -1,252 +0,0 @@
-"use strict";
-/**
- * Generate SQL seed scripts from TypeScript node type definitions.
- *
- * Uses pgsql-deparser to produce individual INSERT statements per node type,
- * suitable for use as separate pgpm migration files.
- *
- * Usage:
- *   npx ts-node src/codegen/generate-seed.ts [--outdir <dir>] [--single] [--pgpm <dir>]
- *
- *   --outdir <dir>   Directory to write individual SQL files (default: stdout)
- *   --single         Emit a single combined seed.sql instead of per-node files
- *   --pgpm <dir>     Generate deploy/revert/verify files in pgpm package layout.
- *                     <dir> is the pgpm package root (e.g. packages/metaschema).
- *                     Files are written relative to this root at:
- *                       deploy/schemas/metaschema_public/tables/node_type_registry/data/seed.sql
- *                       revert/schemas/metaschema_public/tables/node_type_registry/data/seed.sql
- *                       verify/schemas/metaschema_public/tables/node_type_registry/data/seed.sql
- *
- * Examples:
- *   # Print all INSERT statements to stdout
- *   npx ts-node src/codegen/generate-seed.ts
- *
- *   # Generate individual migration files
- *   npx ts-node src/codegen/generate-seed.ts --outdir ./deploy/seed
- *
- *   # Generate a single combined seed file
- *   npx ts-node src/codegen/generate-seed.ts --single --outdir ./deploy
- *
- *   # Generate pgpm deploy/revert/verify files
- *   npx ts-node src/codegen/generate-seed.ts --pgpm ../../constructive-db/packages/metaschema
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = require("fs");
-const path_1 = require("path");
-const pgsql_deparser_1 = require("pgsql-deparser");
-const utils_1 = require("@pgsql/utils");
-const index_1 = require("../index");
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-const MIGRATION_PATH = 'schemas/metaschema_public/tables/node_type_registry/data/seed';
-// ---------------------------------------------------------------------------
-// AST helpers
-// ---------------------------------------------------------------------------
-const astr = (val) => utils_1.nodes.aConst({ sval: utils_1.ast.string({ sval: val }) });
-const makeCast = (arg, typeName) => ({
-    TypeCast: {
-        arg,
-        typeName: {
-            names: [{ String: { sval: typeName } }],
-            typemod: -1,
-        },
-    },
-});
-const makeArrayExpr = (elements) => ({
-    A_ArrayExpr: { elements },
-});
-// ---------------------------------------------------------------------------
-// Build a single INSERT statement for one node type
-// ---------------------------------------------------------------------------
-function buildInsertStmt(nt) {
-    const cols = [
-        'name',
-        'slug',
-        'category',
-        'display_name',
-        'description',
-        'parameter_schema',
-        'tags',
-    ];
-    const vals = [
-        astr(nt.name),
-        astr(nt.slug),
-        astr(nt.category),
-        astr(nt.display_name),
-        astr(nt.description),
-        makeCast(astr(JSON.stringify(nt.parameter_schema)), 'jsonb'),
-        makeArrayExpr(nt.tags.map((t) => astr(t))),
-    ];
-    return {
-        RawStmt: {
-            stmt: {
-                InsertStmt: {
-                    relation: {
-                        schemaname: 'metaschema_public',
-                        relname: 'node_type_registry',
-                        inh: true,
-                        relpersistence: 'p',
-                    },
-                    cols: cols.map((name) => utils_1.nodes.resTarget({ name })),
-                    selectStmt: {
-                        SelectStmt: {
-                            valuesLists: [
-                                {
-                                    List: { items: vals },
-                                },
-                            ],
-                            op: 'SETOP_NONE',
-                            limitOption: 'LIMIT_OPTION_DEFAULT',
-                        },
-                    },
-                    onConflictClause: {
-                        action: 'ONCONFLICT_NOTHING',
-                        infer: {
-                            indexElems: [
-                                {
-                                    IndexElem: {
-                                        name: 'slug',
-                                        ordering: 'SORTBY_DEFAULT',
-                                        nulls_ordering: 'SORTBY_NULLS_DEFAULT',
-                                    },
-                                },
-                            ],
-                        },
-                    },
-                    override: 'OVERRIDING_NOT_SET',
-                },
-            },
-            stmt_len: 1,
-        },
-    };
-}
-// ---------------------------------------------------------------------------
-// pgpm file generators
-// ---------------------------------------------------------------------------
-const GENERATED_HEADER = [
-    '-- GENERATED FILE — DO NOT EDIT',
-    '--',
-    '-- Regenerate with:',
-    '--   cd graphql/node-type-registry && pnpm generate:seed --pgpm ../../constructive-db/packages/metaschema',
-    '--',
-    '',
-].join('\n');
-async function buildDeploySql() {
-    const header = [
-        `-- Deploy ${MIGRATION_PATH} to pg`,
-        '',
-        GENERATED_HEADER,
-        '-- requires: schemas/metaschema_public/tables/node_type_registry/table',
-        '',
-    ].join('\n');
-    const stmts = index_1.allNodeTypes.map(buildInsertStmt);
-    const body = await (0, pgsql_deparser_1.deparse)(stmts);
-    return header + body + '\n';
-}
-function buildRevertSql() {
-    const names = index_1.allNodeTypes.map((nt) => `    '${nt.name}'`);
-    // Wrap names at ~4 per line for readability
-    const chunks = [];
-    for (let i = 0; i < names.length; i += 4) {
-        chunks.push(names.slice(i, i + 4).join(', '));
-    }
-    return [
-        `-- Revert ${MIGRATION_PATH} from pg`,
-        '',
-        GENERATED_HEADER,
-        'DELETE FROM metaschema_public.node_type_registry',
-        'WHERE name IN (',
-        chunks.join(',\n'),
-        ');',
-        '',
-    ].join('\n');
-}
-function buildVerifySql() {
-    // Pick one representative from each category
-    const categories = new Map();
-    for (const nt of index_1.allNodeTypes) {
-        if (!categories.has(nt.category)) {
-            categories.set(nt.category, nt);
-        }
-    }
-    const checks = Array.from(categories.values()).map((nt) => `SELECT 1 FROM metaschema_public.node_type_registry WHERE name = '${nt.name}';`);
-    return [
-        `-- Verify ${MIGRATION_PATH} on pg`,
-        '',
-        GENERATED_HEADER,
-        ...checks,
-        '',
-    ].join('\n');
-}
-// ---------------------------------------------------------------------------
-// File writer helper
-// ---------------------------------------------------------------------------
-function writeFile(filePath, content) {
-    const dir = (0, path_1.join)(filePath, '..');
-    if (!(0, fs_1.existsSync)(dir))
-        (0, fs_1.mkdirSync)(dir, { recursive: true });
-    (0, fs_1.writeFileSync)(filePath, content);
-}
-// ---------------------------------------------------------------------------
-// CLI
-// ---------------------------------------------------------------------------
-async function main() {
-    const args = process.argv.slice(2);
-    const outdirIdx = args.indexOf('--outdir');
-    const outdir = outdirIdx !== -1 ? args[outdirIdx + 1] : undefined;
-    const single = args.includes('--single');
-    const pgpmIdx = args.indexOf('--pgpm');
-    const pgpmRoot = pgpmIdx !== -1 ? args[pgpmIdx + 1] : undefined;
-    // --pgpm mode: generate deploy/revert/verify in pgpm package layout
-    if (pgpmRoot) {
-        const relPath = 'schemas/metaschema_public/tables/node_type_registry/data/seed.sql';
-        const deployPath = (0, path_1.join)(pgpmRoot, 'deploy', relPath);
-        const revertPath = (0, path_1.join)(pgpmRoot, 'revert', relPath);
-        const verifyPath = (0, path_1.join)(pgpmRoot, 'verify', relPath);
-        writeFile(deployPath, await buildDeploySql());
-        writeFile(revertPath, buildRevertSql());
-        writeFile(verifyPath, buildVerifySql());
-        console.log(`Wrote ${index_1.allNodeTypes.length} node types to pgpm layout:`);
-        console.log(`  deploy: ${deployPath}`);
-        console.log(`  revert: ${revertPath}`);
-        console.log(`  verify: ${verifyPath}`);
-        return;
-    }
-    if (single) {
-        // Emit all INSERT statements as a single SQL string
-        const stmts = index_1.allNodeTypes.map(buildInsertStmt);
-        const sql = await (0, pgsql_deparser_1.deparse)(stmts);
-        if (outdir) {
-            if (!(0, fs_1.existsSync)(outdir))
-                (0, fs_1.mkdirSync)(outdir, { recursive: true });
-            (0, fs_1.writeFileSync)((0, path_1.join)(outdir, 'seed.sql'), sql + '\n');
-            console.log(`Wrote ${index_1.allNodeTypes.length} node types to ${(0, path_1.join)(outdir, 'seed.sql')}`);
-        }
-        else {
-            process.stdout.write(sql + '\n');
-        }
-        return;
-    }
-    // Emit individual SQL files per node type
-    const stmts = await Promise.all(index_1.allNodeTypes.map(async (nt) => ({
-        nt,
-        sql: await (0, pgsql_deparser_1.deparse)([buildInsertStmt(nt)]),
-    })));
-    if (outdir) {
-        if (!(0, fs_1.existsSync)(outdir))
-            (0, fs_1.mkdirSync)(outdir, { recursive: true });
-        for (const { nt, sql } of stmts) {
-            const filename = `${nt.slug}.sql`;
-            (0, fs_1.writeFileSync)((0, path_1.join)(outdir, filename), sql + '\n');
-        }
-        console.log(`Wrote ${stmts.length} individual migration files to ${outdir}/`);
-    }
-    else {
-        for (const { nt, sql } of stmts) {
-            console.log(`-- ${nt.name} (${nt.slug})`);
-            console.log(sql + ';\n');
-        }
-    }
-}
-main();

package/esm/codegen/generate-seed.d.ts

@@ -1,32 +0,0 @@
-/**
- * Generate SQL seed scripts from TypeScript node type definitions.
- *
- * Uses pgsql-deparser to produce individual INSERT statements per node type,
- * suitable for use as separate pgpm migration files.
- *
- * Usage:
- *   npx ts-node src/codegen/generate-seed.ts [--outdir <dir>] [--single] [--pgpm <dir>]
- *
- *   --outdir <dir>   Directory to write individual SQL files (default: stdout)
- *   --single         Emit a single combined seed.sql instead of per-node files
- *   --pgpm <dir>     Generate deploy/revert/verify files in pgpm package layout.
- *                     <dir> is the pgpm package root (e.g. packages/metaschema).
- *                     Files are written relative to this root at:
- *                       deploy/schemas/metaschema_public/tables/node_type_registry/data/seed.sql
- *                       revert/schemas/metaschema_public/tables/node_type_registry/data/seed.sql
- *                       verify/schemas/metaschema_public/tables/node_type_registry/data/seed.sql
- *
- * Examples:
- *   # Print all INSERT statements to stdout
- *   npx ts-node src/codegen/generate-seed.ts
- *
- *   # Generate individual migration files
- *   npx ts-node src/codegen/generate-seed.ts --outdir ./deploy/seed
- *
- *   # Generate a single combined seed file
- *   npx ts-node src/codegen/generate-seed.ts --single --outdir ./deploy
- *
- *   # Generate pgpm deploy/revert/verify files
- *   npx ts-node src/codegen/generate-seed.ts --pgpm ../../constructive-db/packages/metaschema
- */
-export {};