node-type-registry 0.2.0

package/data/data-tags.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataTags = void 0;
+exports.DataTags = {
+    name: 'DataTags',
+    slug: 'data_tags',
+    category: 'data',
+    display_name: 'Tags',
+    description: 'Adds a citext[] tags column with GIN index for efficient array containment queries (@>, &&). Standard tagging pattern for categorization and filtering.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "field_name": {
+                "type": "string",
+                "description": "Column name for the tags array",
+                "default": "tags"
+            },
+            "default_value": {
+                "type": "string",
+                "description": "Default value expression for the tags column"
+            },
+            "is_required": {
+                "type": "boolean",
+                "description": "Whether the column has a NOT NULL constraint",
+                "default": false
+            }
+        }
+    },
+    tags: ['tags', 'schema'],
+};

package/data/data-timestamps.d.ts

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

package/data/data-timestamps.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataTimestamps = void 0;
+exports.DataTimestamps = {
+    name: 'DataTimestamps',
+    slug: 'data_timestamps',
+    category: 'data',
+    display_name: 'Timestamps',
+    description: 'Adds automatic timestamp tracking with created_at and updated_at 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: ['timestamps', 'schema'],
+};

package/data/data-trgm.d.ts

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

package/data/data-trgm.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataTrgm = void 0;
+exports.DataTrgm = {
+    name: 'DataTrgm',
+    slug: 'data_trgm',
+    category: 'data',
+    display_name: 'Trigram Search',
+    description: 'Creates GIN trigram indexes (gin_trgm_ops) on specified text/citext fields for fuzzy LIKE/ILIKE/similarity search. Adds @trgmSearch smart tag for PostGraphile integration. Fields must already exist on the table.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "fields": {
+                "type": "array",
+                "items": {
+                    "type": "string"
+                },
+                "description": "Field names to create trigram indexes on (fields must already exist on the table)"
+            }
+        },
+        "required": [
+            "fields"
+        ]
+    },
+    tags: ['search', 'trigram', 'schema'],
+};

package/data/index.d.ts

@@ -0,0 +1,19 @@
+export { DataId } from './data-id';
+export { DataDirectOwner } from './data-direct-owner';
+export { DataEntityMembership } from './data-entity-membership';
+export { DataOwnershipInEntity } from './data-ownership-in-entity';
+export { DataTimestamps } from './data-timestamps';
+export { DataPeoplestamps } from './data-peoplestamps';
+export { DataPublishable } from './data-publishable';
+export { DataSoftDelete } from './data-soft-delete';
+export { DataEmbedding } from './data-embedding';
+export { DataFullTextSearch } from './data-full-text-search';
+export { DataBm25 } from './data-bm25';
+export { DataSearch } from './data-search';
+export { DataPostGIS } from './data-postgis';
+export { DataPostGISAggregate } from './data-postgis-aggregate';
+export { DataJobTrigger } from './data-job-trigger';
+export { DataTags } from './data-tags';
+export { DataStatusField } from './data-status-field';
+export { DataJsonb } from './data-jsonb';
+export { DataTrgm } from './data-trgm';

package/data/index.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataTrgm = exports.DataJsonb = exports.DataStatusField = exports.DataTags = exports.DataJobTrigger = exports.DataPostGISAggregate = exports.DataPostGIS = exports.DataSearch = exports.DataBm25 = exports.DataFullTextSearch = exports.DataEmbedding = exports.DataSoftDelete = exports.DataPublishable = exports.DataPeoplestamps = exports.DataTimestamps = exports.DataOwnershipInEntity = exports.DataEntityMembership = exports.DataDirectOwner = exports.DataId = void 0;
+var data_id_1 = require("./data-id");
+Object.defineProperty(exports, "DataId", { enumerable: true, get: function () { return data_id_1.DataId; } });
+var data_direct_owner_1 = require("./data-direct-owner");
+Object.defineProperty(exports, "DataDirectOwner", { enumerable: true, get: function () { return data_direct_owner_1.DataDirectOwner; } });
+var data_entity_membership_1 = require("./data-entity-membership");
+Object.defineProperty(exports, "DataEntityMembership", { enumerable: true, get: function () { return data_entity_membership_1.DataEntityMembership; } });
+var data_ownership_in_entity_1 = require("./data-ownership-in-entity");
+Object.defineProperty(exports, "DataOwnershipInEntity", { enumerable: true, get: function () { return data_ownership_in_entity_1.DataOwnershipInEntity; } });
+var data_timestamps_1 = require("./data-timestamps");
+Object.defineProperty(exports, "DataTimestamps", { enumerable: true, get: function () { return data_timestamps_1.DataTimestamps; } });
+var data_peoplestamps_1 = require("./data-peoplestamps");
+Object.defineProperty(exports, "DataPeoplestamps", { enumerable: true, get: function () { return data_peoplestamps_1.DataPeoplestamps; } });
+var data_publishable_1 = require("./data-publishable");
+Object.defineProperty(exports, "DataPublishable", { enumerable: true, get: function () { return data_publishable_1.DataPublishable; } });
+var data_soft_delete_1 = require("./data-soft-delete");
+Object.defineProperty(exports, "DataSoftDelete", { enumerable: true, get: function () { return data_soft_delete_1.DataSoftDelete; } });
+var data_embedding_1 = require("./data-embedding");
+Object.defineProperty(exports, "DataEmbedding", { enumerable: true, get: function () { return data_embedding_1.DataEmbedding; } });
+var data_full_text_search_1 = require("./data-full-text-search");
+Object.defineProperty(exports, "DataFullTextSearch", { enumerable: true, get: function () { return data_full_text_search_1.DataFullTextSearch; } });
+var data_bm25_1 = require("./data-bm25");
+Object.defineProperty(exports, "DataBm25", { enumerable: true, get: function () { return data_bm25_1.DataBm25; } });
+var data_search_1 = require("./data-search");
+Object.defineProperty(exports, "DataSearch", { enumerable: true, get: function () { return data_search_1.DataSearch; } });
+var data_postgis_1 = require("./data-postgis");
+Object.defineProperty(exports, "DataPostGIS", { enumerable: true, get: function () { return data_postgis_1.DataPostGIS; } });
+var data_postgis_aggregate_1 = require("./data-postgis-aggregate");
+Object.defineProperty(exports, "DataPostGISAggregate", { enumerable: true, get: function () { return data_postgis_aggregate_1.DataPostGISAggregate; } });
+var data_job_trigger_1 = require("./data-job-trigger");
+Object.defineProperty(exports, "DataJobTrigger", { enumerable: true, get: function () { return data_job_trigger_1.DataJobTrigger; } });
+var data_tags_1 = require("./data-tags");
+Object.defineProperty(exports, "DataTags", { enumerable: true, get: function () { return data_tags_1.DataTags; } });
+var data_status_field_1 = require("./data-status-field");
+Object.defineProperty(exports, "DataStatusField", { enumerable: true, get: function () { return data_status_field_1.DataStatusField; } });
+var data_jsonb_1 = require("./data-jsonb");
+Object.defineProperty(exports, "DataJsonb", { enumerable: true, get: function () { return data_jsonb_1.DataJsonb; } });
+var data_trgm_1 = require("./data-trgm");
+Object.defineProperty(exports, "DataTrgm", { enumerable: true, get: function () { return data_trgm_1.DataTrgm; } });

package/esm/authz/authz-allow-all.d.ts

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

package/esm/authz/authz-allow-all.js

@@ -0,0 +1,12 @@
+export const AuthzAllowAll = {
+    name: 'AuthzAllowAll',
+    slug: 'authz_allow_all',
+    category: 'authz',
+    display_name: 'Public Access',
+    description: 'Allows all access. Generates TRUE expression.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {}
+    },
+    tags: ['authz'],
+};

package/esm/authz/authz-composite.d.ts

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

package/esm/authz/authz-composite.js

@@ -0,0 +1,36 @@
+export const AuthzComposite = {
+    name: 'AuthzComposite',
+    slug: 'authz_composite',
+    category: 'authz',
+    display_name: 'Composite Policy',
+    description: 'Composite authorization policy that combines multiple authorization nodes using boolean logic (AND/OR). The data field contains a JSONB AST with nested authorization nodes.',
+    parameter_schema: {
+        "type": "object",
+        "description": "A composite policy containing nested authorization nodes combined with boolean logic",
+        "properties": {
+            "BoolExpr": {
+                "type": "object",
+                "description": "Boolean expression combining multiple authorization nodes",
+                "properties": {
+                    "boolop": {
+                        "type": "string",
+                        "enum": [
+                            "AND_EXPR",
+                            "OR_EXPR",
+                            "NOT_EXPR"
+                        ],
+                        "description": "Boolean operator: AND_EXPR, OR_EXPR, or NOT_EXPR"
+                    },
+                    "args": {
+                        "type": "array",
+                        "description": "Array of authorization nodes to combine",
+                        "items": {
+                            "type": "object"
+                        }
+                    }
+                }
+            }
+        }
+    },
+    tags: ['composite', 'authz'],
+};

package/esm/authz/authz-deny-all.d.ts

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

package/esm/authz/authz-deny-all.js

@@ -0,0 +1,12 @@
+export const AuthzDenyAll = {
+    name: 'AuthzDenyAll',
+    slug: 'authz_deny_all',
+    category: 'authz',
+    display_name: 'No Access',
+    description: 'Denies all access. Generates FALSE expression.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {}
+    },
+    tags: ['authz'],
+};

package/esm/authz/authz-direct-owner-any.d.ts

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

package/esm/authz/authz-direct-owner-any.js

@@ -0,0 +1,23 @@
+export const AuthzDirectOwnerAny = {
+    name: 'AuthzDirectOwnerAny',
+    slug: 'authz_direct_owner_any',
+    category: 'authz',
+    display_name: 'Multi-Owner Access',
+    description: 'OR logic for multiple ownership fields. Checks if current user matches any of the specified fields.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "entity_fields": {
+                "type": "array",
+                "items": {
+                    "type": "string"
+                },
+                "description": "Array of column names to check for ownership"
+            }
+        },
+        "required": [
+            "entity_fields"
+        ]
+    },
+    tags: ['ownership', 'authz'],
+};

package/esm/authz/authz-direct-owner.d.ts

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

package/esm/authz/authz-direct-owner.js

@@ -0,0 +1,20 @@
+export const AuthzDirectOwner = {
+    name: 'AuthzDirectOwner',
+    slug: 'authz_direct_owner',
+    category: 'authz',
+    display_name: 'Direct Ownership',
+    description: 'Direct equality comparison between a table column and the current user ID. Simplest authorization pattern with no subqueries.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "entity_field": {
+                "type": "string",
+                "description": "Column name containing the owner user ID (e.g., owner_id)"
+            }
+        },
+        "required": [
+            "entity_field"
+        ]
+    },
+    tags: ['ownership', 'authz'],
+};

package/esm/authz/authz-entity-membership.d.ts

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

package/esm/authz/authz-entity-membership.js

@@ -0,0 +1,46 @@
+export const AuthzEntityMembership = {
+    name: 'AuthzEntityMembership',
+    slug: 'authz_entity_membership',
+    category: 'authz',
+    display_name: 'Entity Membership',
+    description: 'Membership check scoped by a field on the row through the SPRT table. Verifies user has membership in the entity referenced by the row.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "entity_field": {
+                "type": "string",
+                "description": "Column name referencing the entity (e.g., entity_id, org_id)"
+            },
+            "membership_type": {
+                "type": [
+                    "integer",
+                    "string"
+                ],
+                "description": "Scope: 1=app, 2=org, 3=group (or string name resolved via membership_types_module)"
+            },
+            "permission": {
+                "type": "string",
+                "description": "Single permission name to check (resolved to bitstring mask)"
+            },
+            "permissions": {
+                "type": "array",
+                "items": {
+                    "type": "string"
+                },
+                "description": "Multiple permission names to check (ORed together into mask)"
+            },
+            "is_admin": {
+                "type": "boolean",
+                "description": "If true, require is_admin flag"
+            },
+            "is_owner": {
+                "type": "boolean",
+                "description": "If true, require is_owner flag"
+            }
+        },
+        "required": [
+            "entity_field"
+        ]
+    },
+    tags: ['membership', 'authz'],
+};

package/esm/authz/authz-member-list.d.ts

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

package/esm/authz/authz-member-list.js

@@ -0,0 +1,20 @@
+export const AuthzMemberList = {
+    name: 'AuthzMemberList',
+    slug: 'authz_member_list',
+    category: 'authz',
+    display_name: 'Member List',
+    description: 'Check if current user is in an array column on the same row.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "array_field": {
+                "type": "string",
+                "description": "Column name containing the array of user IDs"
+            }
+        },
+        "required": [
+            "array_field"
+        ]
+    },
+    tags: ['ownership', 'authz'],
+};

package/esm/authz/authz-membership-check.d.ts

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

package/esm/authz/authz-membership-check.js

@@ -0,0 +1,42 @@
+export const AuthzMembership = {
+    name: 'AuthzMembership',
+    slug: 'authz_membership_check',
+    category: 'authz',
+    display_name: 'Membership Check',
+    description: 'Membership check that verifies the user has membership (optionally with specific permission) without binding to any entity from the row. Uses EXISTS subquery against SPRT table.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "membership_type": {
+                "type": [
+                    "integer",
+                    "string"
+                ],
+                "description": "Scope: 1=app, 2=org, 3=group (or string name resolved via membership_types_module)"
+            },
+            "permission": {
+                "type": "string",
+                "description": "Single permission name to check (resolved to bitstring mask)"
+            },
+            "permissions": {
+                "type": "array",
+                "items": {
+                    "type": "string"
+                },
+                "description": "Multiple permission names to check (ORed together into mask)"
+            },
+            "is_admin": {
+                "type": "boolean",
+                "description": "If true, require is_admin flag"
+            },
+            "is_owner": {
+                "type": "boolean",
+                "description": "If true, require is_owner flag"
+            }
+        },
+        "required": [
+            "membership_type"
+        ]
+    },
+    tags: ['membership', 'authz'],
+};

package/esm/authz/authz-org-hierarchy.d.ts

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

package/esm/authz/authz-org-hierarchy.js

@@ -0,0 +1,38 @@
+export const AuthzOrgHierarchy = {
+    name: 'AuthzOrgHierarchy',
+    slug: 'authz_org_hierarchy',
+    category: 'authz',
+    display_name: 'Org Hierarchy',
+    description: 'Organizational hierarchy visibility using closure table. Managers can see subordinate data or subordinates can see manager data.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "direction": {
+                "type": "string",
+                "enum": [
+                    "up",
+                    "down"
+                ],
+                "description": "down=manager sees subordinates, up=subordinate sees managers"
+            },
+            "entity_field": {
+                "type": "string",
+                "description": "Field referencing the org entity",
+                "default": "entity_id"
+            },
+            "anchor_field": {
+                "type": "string",
+                "description": "Field referencing the user (e.g., owner_id)"
+            },
+            "max_depth": {
+                "type": "integer",
+                "description": "Optional max depth to limit visibility"
+            }
+        },
+        "required": [
+            "direction",
+            "anchor_field"
+        ]
+    },
+    tags: ['membership', 'hierarchy', 'authz'],
+};

package/esm/authz/authz-peer-ownership.d.ts

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

package/esm/authz/authz-peer-ownership.js

@@ -0,0 +1,46 @@
+export const AuthzPeerOwnership = {
+    name: 'AuthzPeerOwnership',
+    slug: 'authz_peer_ownership',
+    category: 'authz',
+    display_name: 'Peer Ownership',
+    description: 'Peer visibility through shared entity membership. Authorizes access to user-owned rows when the owner and current user are both members of the same entity. Self-joins the SPRT table to find peers.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "owner_field": {
+                "type": "string",
+                "description": "Column name on protected table referencing the owning user (e.g., owner_id)"
+            },
+            "membership_type": {
+                "type": [
+                    "integer",
+                    "string"
+                ],
+                "description": "Scope: 1=app, 2=org, 3=group (or string name resolved via membership_types_module)"
+            },
+            "permission": {
+                "type": "string",
+                "description": "Single permission name to check on the current user membership (resolved to bitstring mask)"
+            },
+            "permissions": {
+                "type": "array",
+                "items": {
+                    "type": "string"
+                },
+                "description": "Multiple permission names to check on the current user membership (ORed together into mask)"
+            },
+            "is_admin": {
+                "type": "boolean",
+                "description": "If true, require is_admin flag on current user membership"
+            },
+            "is_owner": {
+                "type": "boolean",
+                "description": "If true, require is_owner flag on current user membership"
+            }
+        },
+        "required": [
+            "owner_field"
+        ]
+    },
+    tags: ['membership', 'peer', 'authz'],
+};

package/esm/authz/authz-publishable.d.ts

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

package/esm/authz/authz-publishable.js

@@ -0,0 +1,28 @@
+export const AuthzPublishable = {
+    name: 'AuthzPublishable',
+    slug: 'authz_publishable',
+    category: 'authz',
+    display_name: 'Published Content',
+    description: 'Published state access control. Restricts access to records that are published.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "is_published_field": {
+                "type": "string",
+                "description": "Boolean field indicating published state",
+                "default": "is_published"
+            },
+            "published_at_field": {
+                "type": "string",
+                "description": "Timestamp field for publish time",
+                "default": "published_at"
+            },
+            "require_published_at": {
+                "type": "boolean",
+                "description": "Require published_at to be non-null and <= now()",
+                "default": true
+            }
+        }
+    },
+    tags: ['temporal', 'publishing', 'authz'],
+};

package/esm/authz/authz-related-entity-membership.d.ts

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

package/esm/authz/authz-related-entity-membership.js

@@ -0,0 +1,68 @@
+export const AuthzRelatedEntityMembership = {
+    name: 'AuthzRelatedEntityMembership',
+    slug: 'authz_related_entity_membership',
+    category: 'authz',
+    display_name: 'Related Entity Membership',
+    description: 'JOIN-based membership verification through related tables. Joins SPRT table with another table to verify membership.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "entity_field": {
+                "type": "string",
+                "description": "Column name on protected table referencing the join table"
+            },
+            "membership_type": {
+                "type": [
+                    "integer",
+                    "string"
+                ],
+                "description": "Scope: 1=app, 2=org, 3=group (or string name resolved via membership_types_module)"
+            },
+            "obj_table_id": {
+                "type": "string",
+                "format": "uuid",
+                "description": "UUID of the join table (alternative to obj_schema/obj_table)"
+            },
+            "obj_schema": {
+                "type": "string",
+                "description": "Schema of the join table (or use obj_table_id)"
+            },
+            "obj_table": {
+                "type": "string",
+                "description": "Name of the join table (or use obj_table_id)"
+            },
+            "obj_field_id": {
+                "type": "string",
+                "format": "uuid",
+                "description": "UUID of field on join table (alternative to obj_field)"
+            },
+            "obj_field": {
+                "type": "string",
+                "description": "Field name on join table to match against SPRT entity_id"
+            },
+            "permission": {
+                "type": "string",
+                "description": "Single permission name to check (resolved to bitstring mask)"
+            },
+            "permissions": {
+                "type": "array",
+                "items": {
+                    "type": "string"
+                },
+                "description": "Multiple permission names to check (ORed together into mask)"
+            },
+            "is_admin": {
+                "type": "boolean",
+                "description": "If true, require is_admin flag"
+            },
+            "is_owner": {
+                "type": "boolean",
+                "description": "If true, require is_owner flag"
+            }
+        },
+        "required": [
+            "entity_field"
+        ]
+    },
+    tags: ['membership', 'authz'],
+};

package/esm/authz/authz-related-member-list.d.ts

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