node-type-registry 0.2.0

package/data/data-job-trigger.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataJobTrigger = void 0;
+exports.DataJobTrigger = {
+    name: 'DataJobTrigger',
+    slug: 'data_job_trigger',
+    category: 'data',
+    display_name: 'Job Trigger',
+    description: 'Dynamically creates PostgreSQL triggers that enqueue jobs via app_jobs.add_job() when table rows are inserted, updated, or deleted. Supports configurable payload strategies (full row, row ID, selected fields, or custom mapping), conditional firing via WHEN clauses, watched field changes, and extended job options (queue, priority, delay, max attempts).',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "task_identifier": {
+                "type": "string",
+                "description": "Job task identifier passed to add_job (e.g., process_invoice, sync_to_stripe)"
+            },
+            "payload_strategy": {
+                "type": "string",
+                "enum": [
+                    "row",
+                    "row_id",
+                    "fields",
+                    "custom"
+                ],
+                "description": "How to build the job payload: row (full NEW/OLD), row_id (just id), fields (selected columns), custom (mapped columns)",
+                "default": "row_id"
+            },
+            "payload_fields": {
+                "type": "array",
+                "items": {
+                    "type": "string"
+                },
+                "description": "Column names to include in payload (only for fields strategy)"
+            },
+            "payload_custom": {
+                "type": "object",
+                "additionalProperties": {
+                    "type": "string"
+                },
+                "description": "Key-to-column mapping for custom payload (e.g., {\"invoice_id\": \"id\", \"total\": \"amount\"})"
+            },
+            "events": {
+                "type": "array",
+                "items": {
+                    "type": "string",
+                    "enum": [
+                        "INSERT",
+                        "UPDATE",
+                        "DELETE"
+                    ]
+                },
+                "description": "Trigger events to create",
+                "default": [
+                    "INSERT",
+                    "UPDATE"
+                ]
+            },
+            "include_old": {
+                "type": "boolean",
+                "description": "Include OLD row in payload (for UPDATE triggers)",
+                "default": false
+            },
+            "include_meta": {
+                "type": "boolean",
+                "description": "Include table/schema metadata in payload",
+                "default": false
+            },
+            "condition_field": {
+                "type": "string",
+                "description": "Column name for conditional WHEN clause (fires only when field equals condition_value)"
+            },
+            "condition_value": {
+                "type": "string",
+                "description": "Value to compare against condition_field in WHEN clause"
+            },
+            "watch_fields": {
+                "type": "array",
+                "items": {
+                    "type": "string"
+                },
+                "description": "For UPDATE triggers, only fire when these fields change (uses DISTINCT FROM)"
+            },
+            "job_key": {
+                "type": "string",
+                "description": "Static job key for upsert semantics (prevents duplicate jobs)"
+            },
+            "queue_name": {
+                "type": "string",
+                "description": "Job queue name for routing to specific workers"
+            },
+            "priority": {
+                "type": "integer",
+                "description": "Job priority (lower = higher priority)",
+                "default": 0
+            },
+            "run_at_delay": {
+                "type": "string",
+                "description": "Delay before job runs as PostgreSQL interval (e.g., 30 seconds, 5 minutes)"
+            },
+            "max_attempts": {
+                "type": "integer",
+                "description": "Maximum retry attempts for the job",
+                "default": 25
+            }
+        },
+        "required": [
+            "task_identifier"
+        ]
+    },
+    tags: ['jobs', 'triggers', 'async'],
+};

package/data/data-jsonb.d.ts

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

package/data/data-jsonb.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataJsonb = void 0;
+exports.DataJsonb = {
+    name: 'DataJsonb',
+    slug: 'data_jsonb',
+    category: 'data',
+    display_name: 'JSONB Field',
+    description: 'Adds a JSONB column with optional GIN index for containment queries (@>, ?, ?|, ?&). Standard pattern for semi-structured metadata.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "field_name": {
+                "type": "string",
+                "description": "Column name for the JSONB field",
+                "default": "metadata"
+            },
+            "default_value": {
+                "type": "string",
+                "description": "Default value expression"
+            },
+            "is_required": {
+                "type": "boolean",
+                "description": "Whether the column has a NOT NULL constraint",
+                "default": false
+            },
+            "create_index": {
+                "type": "boolean",
+                "description": "Whether to create a GIN index",
+                "default": true
+            }
+        }
+    },
+    tags: ['jsonb', 'schema'],
+};

package/data/data-ownership-in-entity.d.ts

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

package/data/data-ownership-in-entity.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataOwnershipInEntity = void 0;
+exports.DataOwnershipInEntity = {
+    name: 'DataOwnershipInEntity',
+    slug: 'data_ownership_in_entity',
+    category: 'data',
+    display_name: 'Ownership In Entity',
+    description: 'Combines direct ownership with entity scoping. Adds both owner_id and entity_id columns. Enables AuthzDirectOwner, AuthzEntityMembership, and AuthzOrgHierarchy authorization. Particularly useful for OrgHierarchy where a user owns a row (owner_id) within an entity (entity_id), and managers above can see subordinate-owned records via the hierarchy closure table.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "include_id": {
+                "type": "boolean",
+                "description": "If true, also adds a UUID primary key column with auto-generation",
+                "default": true
+            },
+            "include_user_fk": {
+                "type": "boolean",
+                "description": "If true, adds foreign key constraints from owner_id and entity_id to the users table",
+                "default": true
+            }
+        }
+    },
+    tags: ['ownership', 'membership', 'hierarchy', 'schema'],
+};

package/data/data-peoplestamps.d.ts

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

package/data/data-peoplestamps.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataPeoplestamps = void 0;
+exports.DataPeoplestamps = {
+    name: 'DataPeoplestamps',
+    slug: 'data_peoplestamps',
+    category: 'data',
+    display_name: 'Peoplestamps',
+    description: 'Adds user tracking for creates/updates with created_by and updated_by columns.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "include_id": {
+                "type": "boolean",
+                "description": "If true, also adds a UUID primary key column with auto-generation",
+                "default": true
+            },
+            "include_user_fk": {
+                "type": "boolean",
+                "description": "If true, adds foreign key constraints from created_by and updated_by to the users table",
+                "default": false
+            }
+        }
+    },
+    tags: ['timestamps', 'schema'],
+};

package/data/data-postgis-aggregate.d.ts

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

package/data/data-postgis-aggregate.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataPostGISAggregate = void 0;
+exports.DataPostGISAggregate = {
+    name: 'DataPostGISAggregate',
+    slug: 'data_postgis_aggregate',
+    category: 'data',
+    display_name: 'PostGIS Aggregate Geometry',
+    description: 'Creates a derived/materialized geometry field on the parent table that automatically aggregates geometries from a source (child) table via triggers. When child rows are inserted/updated/deleted, the parent aggregate field is recalculated using the specified PostGIS aggregation function (ST_Union, ST_Collect, ST_ConvexHull, ST_ConcaveHull). Useful for materializing spatial boundaries from collections of points or polygons.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "field_name": {
+                "type": "string",
+                "description": "Name of the aggregate geometry column on the parent table",
+                "default": "geom_aggregate"
+            },
+            "source_table_id": {
+                "type": "string",
+                "format": "uuid",
+                "description": "UUID of the source (child) table containing individual geometries"
+            },
+            "source_geom_field": {
+                "type": "string",
+                "description": "Name of the geometry column on the source table",
+                "default": "geom"
+            },
+            "source_fk_field": {
+                "type": "string",
+                "description": "Name of the foreign key column on the source table pointing to the parent"
+            },
+            "aggregate_function": {
+                "type": "string",
+                "enum": [
+                    "union",
+                    "collect",
+                    "convex_hull",
+                    "concave_hull"
+                ],
+                "description": "PostGIS aggregation function: union (ST_Union, merges overlapping), collect (ST_Collect, groups without merging), convex_hull (smallest convex polygon), concave_hull (tighter boundary)",
+                "default": "union"
+            },
+            "geometry_type": {
+                "type": "string",
+                "enum": [
+                    "Point",
+                    "LineString",
+                    "Polygon",
+                    "MultiPoint",
+                    "MultiLineString",
+                    "MultiPolygon",
+                    "GeometryCollection",
+                    "Geometry"
+                ],
+                "description": "Output geometry type constraint for the aggregate field",
+                "default": "MultiPolygon"
+            },
+            "srid": {
+                "type": "integer",
+                "description": "Spatial Reference System Identifier (e.g. 4326 for WGS84)",
+                "default": 4326
+            },
+            "dimension": {
+                "type": "integer",
+                "enum": [
+                    2,
+                    3,
+                    4
+                ],
+                "description": "Coordinate dimension (2=XY, 3=XYZ, 4=XYZM)",
+                "default": 2
+            },
+            "use_geography": {
+                "type": "boolean",
+                "description": "Use geography type instead of geometry",
+                "default": false
+            },
+            "index_method": {
+                "type": "string",
+                "enum": [
+                    "gist",
+                    "spgist"
+                ],
+                "description": "Spatial index method for the aggregate field",
+                "default": "gist"
+            }
+        },
+        "required": [
+            "source_table_id",
+            "source_fk_field"
+        ]
+    },
+    tags: ['spatial', 'postgis', 'geometry', 'aggregate', 'schema'],
+};

package/data/data-postgis.d.ts

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

package/data/data-postgis.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataPostGIS = void 0;
+exports.DataPostGIS = {
+    name: 'DataPostGIS',
+    slug: 'data_postgis',
+    category: 'data',
+    display_name: 'PostGIS Geometry',
+    description: 'Adds a PostGIS geometry or geography column with a spatial index (GiST or SP-GiST). Supports configurable geometry types (Point, Polygon, etc.), SRID, and dimensionality. The graphile-postgis plugin auto-detects geometry/geography columns by codec type for spatial filtering (ST_Contains, ST_DWithin, bbox operators).',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "field_name": {
+                "type": "string",
+                "description": "Name of the geometry/geography column",
+                "default": "geom"
+            },
+            "geometry_type": {
+                "type": "string",
+                "enum": [
+                    "Point",
+                    "LineString",
+                    "Polygon",
+                    "MultiPoint",
+                    "MultiLineString",
+                    "MultiPolygon",
+                    "GeometryCollection",
+                    "Geometry"
+                ],
+                "description": "PostGIS geometry type constraint",
+                "default": "Point"
+            },
+            "srid": {
+                "type": "integer",
+                "description": "Spatial Reference System Identifier (e.g. 4326 for WGS84)",
+                "default": 4326
+            },
+            "dimension": {
+                "type": "integer",
+                "enum": [
+                    2,
+                    3,
+                    4
+                ],
+                "description": "Coordinate dimension (2=XY, 3=XYZ, 4=XYZM)",
+                "default": 2
+            },
+            "use_geography": {
+                "type": "boolean",
+                "description": "Use geography type instead of geometry (for geodetic calculations on the sphere)",
+                "default": false
+            },
+            "index_method": {
+                "type": "string",
+                "enum": [
+                    "gist",
+                    "spgist"
+                ],
+                "description": "Spatial index method",
+                "default": "gist"
+            }
+        }
+    },
+    tags: ['spatial', 'postgis', 'geometry', 'schema'],
+};

package/data/data-publishable.d.ts

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

package/data/data-publishable.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataPublishable = void 0;
+exports.DataPublishable = {
+    name: 'DataPublishable',
+    slug: 'data_publishable',
+    category: 'data',
+    display_name: 'Publishable',
+    description: 'Adds publish state columns (is_published, published_at) for content visibility. Enables AuthzPublishable and AuthzTemporal authorization.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "include_id": {
+                "type": "boolean",
+                "description": "If true, also adds a UUID primary key column with auto-generation",
+                "default": true
+            }
+        }
+    },
+    tags: ['publishing', 'temporal', 'schema'],
+};

package/data/data-search.d.ts

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

package/data/data-search.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataSearch = void 0;
+exports.DataSearch = {
+    name: 'DataSearch',
+    slug: 'data_search',
+    category: 'data',
+    display_name: 'Unified Search',
+    description: 'Composite node type that orchestrates multiple search modalities (full-text search, BM25, embeddings, trigram) on a single table. Configures per-table search score weights, normalization strategy, and recency boost via the @searchConfig smart tag.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "full_text_search": {
+                "type": "object",
+                "description": "DataFullTextSearch parameters. Omit to skip FTS setup.",
+                "properties": {
+                    "field_name": {
+                        "type": "string",
+                        "default": "search"
+                    },
+                    "source_fields": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "properties": {
+                                "field": {
+                                    "type": "string"
+                                },
+                                "weight": {
+                                    "type": "string",
+                                    "enum": [
+                                        "A",
+                                        "B",
+                                        "C",
+                                        "D"
+                                    ]
+                                },
+                                "lang": {
+                                    "type": "string"
+                                }
+                            },
+                            "required": [
+                                "field"
+                            ]
+                        }
+                    },
+                    "search_score_weight": {
+                        "type": "number",
+                        "default": 1
+                    }
+                }
+            },
+            "bm25": {
+                "type": "object",
+                "description": "DataBm25 parameters. Omit to skip BM25 setup.",
+                "properties": {
+                    "field_name": {
+                        "type": "string"
+                    },
+                    "text_config": {
+                        "type": "string",
+                        "default": "english"
+                    },
+                    "k1": {
+                        "type": "number"
+                    },
+                    "b": {
+                        "type": "number"
+                    },
+                    "search_score_weight": {
+                        "type": "number",
+                        "default": 1
+                    }
+                }
+            },
+            "embedding": {
+                "type": "object",
+                "description": "DataEmbedding parameters. Omit to skip embedding setup.",
+                "properties": {
+                    "field_name": {
+                        "type": "string",
+                        "default": "embedding"
+                    },
+                    "dimensions": {
+                        "type": "integer",
+                        "default": 768
+                    },
+                    "index_method": {
+                        "type": "string",
+                        "enum": [
+                            "hnsw",
+                            "ivfflat"
+                        ]
+                    },
+                    "metric": {
+                        "type": "string",
+                        "enum": [
+                            "cosine",
+                            "l2",
+                            "ip"
+                        ]
+                    },
+                    "source_fields": {
+                        "type": "array",
+                        "items": {
+                            "type": "string"
+                        }
+                    },
+                    "search_score_weight": {
+                        "type": "number",
+                        "default": 1
+                    }
+                }
+            },
+            "trgm_fields": {
+                "type": "array",
+                "items": {
+                    "type": "string"
+                },
+                "description": "Field names to tag with @trgmSearch for fuzzy/typo-tolerant matching"
+            },
+            "search_config": {
+                "type": "object",
+                "description": "Unified search score configuration written to @searchConfig smart tag",
+                "properties": {
+                    "weights": {
+                        "type": "object",
+                        "description": "Per-algorithm weights: {tsv: 1.5, bm25: 1.0, pgvector: 0.8, trgm: 0.3}"
+                    },
+                    "normalization": {
+                        "type": "string",
+                        "enum": [
+                            "linear",
+                            "sigmoid"
+                        ],
+                        "description": "Score normalization strategy",
+                        "default": "linear"
+                    },
+                    "boost_recent": {
+                        "type": "boolean",
+                        "description": "Enable recency boost for search results",
+                        "default": false
+                    },
+                    "boost_recency_field": {
+                        "type": "string",
+                        "description": "Timestamp field for recency boost (e.g. created_at, updated_at)"
+                    },
+                    "boost_recency_decay": {
+                        "type": "number",
+                        "description": "Decay rate for recency boost (0-1, lower = faster decay)",
+                        "default": 0.5
+                    }
+                }
+            }
+        }
+    },
+    tags: ['search', 'composite', 'schema'],
+};

package/data/data-soft-delete.d.ts

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

package/data/data-soft-delete.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataSoftDelete = void 0;
+exports.DataSoftDelete = {
+    name: 'DataSoftDelete',
+    slug: 'data_soft_delete',
+    category: 'data',
+    display_name: 'Soft Delete',
+    description: 'Adds soft delete support with deleted_at and is_deleted columns.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "include_id": {
+                "type": "boolean",
+                "description": "If true, also adds a UUID primary key column with auto-generation",
+                "default": true
+            }
+        }
+    },
+    tags: ['schema'],
+};

package/data/data-status-field.d.ts

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

package/data/data-status-field.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataStatusField = void 0;
+exports.DataStatusField = {
+    name: 'DataStatusField',
+    slug: 'data_status_field',
+    category: 'data',
+    display_name: 'Status Field',
+    description: 'Adds a status column with B-tree index for efficient equality filtering and sorting. Optionally constrains values via CHECK constraint when allowed_values is provided.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "field_name": {
+                "type": "string",
+                "description": "Column name for the status field",
+                "default": "status"
+            },
+            "type": {
+                "type": "string",
+                "description": "Column type (text or citext)",
+                "default": "text"
+            },
+            "default_value": {
+                "type": "string",
+                "description": "Default value expression (e.g., active)"
+            },
+            "is_required": {
+                "type": "boolean",
+                "description": "Whether the column has a NOT NULL constraint",
+                "default": true
+            },
+            "allowed_values": {
+                "type": "array",
+                "items": {
+                    "type": "string"
+                },
+                "description": "If provided, creates a CHECK constraint restricting the column to these values"
+            }
+        }
+    },
+    tags: ['status', 'schema'],
+};

package/data/data-tags.d.ts

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