node-type-registry 0.2.0

package/preset.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeTypeRegistryPreset = void 0;
+const plugin_1 = require("graphile-settings/plugins/blueprint-types/plugin");
+const index_1 = require("./index");
+exports.NodeTypeRegistryPreset = {
+    plugins: [(0, plugin_1.createBlueprintTypesPlugin)(index_1.allNodeTypes)],
+};

package/relation/index.d.ts

@@ -0,0 +1,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';

package/relation/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+Object.defineProperty(exports, "RelationHasOne", { enumerable: true, get: function () { return relation_has_one_1.RelationHasOne; } });
+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; } });

package/relation/relation-belongs-to.d.ts

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

package/relation/relation-belongs-to.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationBelongsTo = void 0;
+exports.RelationBelongsTo = {
+    name: 'RelationBelongsTo',
+    slug: 'relation_belongs_to',
+    category: 'relation',
+    display_name: 'Belongs To',
+    description: 'Creates a foreign key field on the source table referencing the target table. Auto-derives the FK field name from the target table name using inflection (e.g., projects derives project_id). delete_action is required and must be explicitly provided by the caller.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "source_table_id": {
+                "type": "string",
+                "format": "uuid",
+                "description": "Table that will have the FK field added"
+            },
+            "target_table_id": {
+                "type": "string",
+                "format": "uuid",
+                "description": "Table being referenced by the FK"
+            },
+            "field_name": {
+                "type": "string",
+                "description": "FK field name on the source table. Auto-derived from target table name if omitted (e.g., projects → project_id)"
+            },
+            "delete_action": {
+                "type": "string",
+                "enum": [
+                    "c",
+                    "r",
+                    "n",
+                    "d",
+                    "a"
+                ],
+                "description": "FK delete action: c=CASCADE, r=RESTRICT, n=SET NULL, d=SET DEFAULT, a=NO ACTION. Required."
+            },
+            "is_required": {
+                "type": "boolean",
+                "description": "Whether the FK field is NOT NULL",
+                "default": true
+            }
+        },
+        "required": [
+            "source_table_id",
+            "target_table_id",
+            "delete_action"
+        ]
+    },
+    tags: ['relation', 'foreign_key', 'schema'],
+};

package/relation/relation-has-many.d.ts

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

package/relation/relation-has-many.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationHasMany = void 0;
+exports.RelationHasMany = {
+    name: 'RelationHasMany',
+    slug: 'relation_has_many',
+    category: 'relation',
+    display_name: 'Has Many',
+    description: 'Creates a foreign key field on the target table referencing the source table. Inverse of RelationBelongsTo — same FK, different perspective. "projects has many tasks" creates tasks.project_id. Auto-derives the FK field name from the source table name using inflection. delete_action is required and must be explicitly provided by the caller.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "source_table_id": {
+                "type": "string",
+                "format": "uuid",
+                "description": "Parent table being referenced by the FK (e.g., projects in projects has many tasks)"
+            },
+            "target_table_id": {
+                "type": "string",
+                "format": "uuid",
+                "description": "Child table that receives the FK field (e.g., tasks in projects has many tasks)"
+            },
+            "field_name": {
+                "type": "string",
+                "description": "FK field name on the target table. Auto-derived from source table name if omitted (e.g., projects derives project_id)"
+            },
+            "delete_action": {
+                "type": "string",
+                "enum": [
+                    "c",
+                    "r",
+                    "n",
+                    "d",
+                    "a"
+                ],
+                "description": "FK delete action: c=CASCADE, r=RESTRICT, n=SET NULL, d=SET DEFAULT, a=NO ACTION. Required."
+            },
+            "is_required": {
+                "type": "boolean",
+                "description": "Whether the FK field is NOT NULL",
+                "default": true
+            }
+        },
+        "required": [
+            "source_table_id",
+            "target_table_id",
+            "delete_action"
+        ]
+    },
+    tags: ['relation', 'foreign_key', 'has_many', 'schema'],
+};

package/relation/relation-has-one.d.ts

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

package/relation/relation-has-one.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationHasOne = void 0;
+exports.RelationHasOne = {
+    name: 'RelationHasOne',
+    slug: 'relation_has_one',
+    category: 'relation',
+    display_name: 'Has One',
+    description: 'Creates a foreign key field with a unique constraint on the source table referencing the target table. Enforces 1:1 cardinality. Auto-derives the FK field name from the target table name using inflection. delete_action is required and must be explicitly provided by the caller.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "source_table_id": {
+                "type": "string",
+                "format": "uuid",
+                "description": "Table that will have the FK field and unique constraint"
+            },
+            "target_table_id": {
+                "type": "string",
+                "format": "uuid",
+                "description": "Table being referenced by the FK"
+            },
+            "field_name": {
+                "type": "string",
+                "description": "FK field name on the source table. Auto-derived from target table name if omitted (e.g., users → user_id)"
+            },
+            "delete_action": {
+                "type": "string",
+                "enum": [
+                    "c",
+                    "r",
+                    "n",
+                    "d",
+                    "a"
+                ],
+                "description": "FK delete action: c=CASCADE, r=RESTRICT, n=SET NULL, d=SET DEFAULT, a=NO ACTION. Required."
+            },
+            "is_required": {
+                "type": "boolean",
+                "description": "Whether the FK field is NOT NULL",
+                "default": true
+            }
+        },
+        "required": [
+            "source_table_id",
+            "target_table_id",
+            "delete_action"
+        ]
+    },
+    tags: ['relation', 'foreign_key', 'unique', 'schema'],
+};

package/relation/relation-many-to-many.d.ts

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

package/relation/relation-many-to-many.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationManyToMany = void 0;
+exports.RelationManyToMany = {
+    name: 'RelationManyToMany',
+    slug: 'relation_many_to_many',
+    category: 'relation',
+    display_name: 'Many to Many',
+    description: 'Creates a junction table between source and target tables with auto-derived naming and FK fields. The trigger creates a bare table (no implicit DataId or any node_type), adds FK fields to both tables, optionally creates a composite PK (use_composite_key), then forwards all security config to secure_table_provision as-is. The trigger never injects values the caller did not provide. Junction table FKs always CASCADE on delete.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "source_table_id": {
+                "type": "string",
+                "format": "uuid",
+                "description": "First table in the M:N relationship"
+            },
+            "target_table_id": {
+                "type": "string",
+                "format": "uuid",
+                "description": "Second table in the M:N relationship"
+            },
+            "junction_table_id": {
+                "type": "string",
+                "format": "uuid",
+                "description": "Existing junction table to use. If uuid_nil(), a new bare table is created"
+            },
+            "junction_table_name": {
+                "type": "string",
+                "description": "Junction table name. Auto-derived from both table names if omitted (e.g., projects + tags derives project_tags)"
+            },
+            "source_field_name": {
+                "type": "string",
+                "description": "FK field name on junction for source table. Auto-derived if omitted (e.g., projects derives project_id)"
+            },
+            "target_field_name": {
+                "type": "string",
+                "description": "FK field name on junction for target table. Auto-derived if omitted (e.g., tags derives tag_id)"
+            },
+            "use_composite_key": {
+                "type": "boolean",
+                "description": "When true, creates a composite PK from the two FK fields. When false, no PK is created by the trigger (use node_type=DataId for UUID PK). Mutually exclusive with node_type=DataId.",
+                "default": false
+            },
+            "node_type": {
+                "type": "string",
+                "description": "Generator for field creation on junction table. Forwarded to secure_table_provision as-is. Examples: DataId, DataEntityMembership, DataDirectOwner. NULL means no additional fields."
+            },
+            "node_data": {
+                "type": "object",
+                "description": "Configuration for the generator. Forwarded to secure_table_provision as-is. Only used when node_type is set."
+            },
+            "grant_roles": {
+                "type": "array",
+                "items": {
+                    "type": "string"
+                },
+                "description": "Database roles to grant privileges to. Forwarded to secure_table_provision as-is. Default: [authenticated]"
+            },
+            "grant_privileges": {
+                "type": "array",
+                "description": "Privilege grants for the junction table. Forwarded to secure_table_provision as-is. Default: select/insert/delete for all columns"
+            },
+            "policy_type": {
+                "type": "string",
+                "description": "RLS policy type for the junction table. Forwarded to secure_table_provision as-is. NULL means no policy."
+            },
+            "policy_privileges": {
+                "type": "array",
+                "items": {
+                    "type": "string"
+                },
+                "description": "Privileges the policy applies to. Forwarded to secure_table_provision as-is. NULL means derived from grant_privileges verbs."
+            },
+            "policy_role": {
+                "type": "string",
+                "description": "Database role the policy targets. Forwarded to secure_table_provision as-is. NULL means falls back to first grant_role."
+            },
+            "policy_permissive": {
+                "type": "boolean",
+                "description": "Whether the policy is PERMISSIVE (true) or RESTRICTIVE (false). Forwarded to secure_table_provision as-is.",
+                "default": true
+            },
+            "policy_data": {
+                "type": "object",
+                "description": "Policy configuration forwarded to secure_table_provision as-is. Structure varies by policy_type."
+            }
+        },
+        "required": [
+            "source_table_id",
+            "target_table_id"
+        ]
+    },
+    tags: ['relation', 'junction', 'many_to_many', 'schema'],
+};

package/table/index.d.ts

@@ -0,0 +1,3 @@
+export { TableUserProfiles } from './table-user-profiles';
+export { TableOrganizationSettings } from './table-organization-settings';
+export { TableUserSettings } from './table-user-settings';

package/table/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableUserSettings = exports.TableOrganizationSettings = exports.TableUserProfiles = void 0;
+var table_user_profiles_1 = require("./table-user-profiles");
+Object.defineProperty(exports, "TableUserProfiles", { enumerable: true, get: function () { return table_user_profiles_1.TableUserProfiles; } });
+var table_organization_settings_1 = require("./table-organization-settings");
+Object.defineProperty(exports, "TableOrganizationSettings", { enumerable: true, get: function () { return table_organization_settings_1.TableOrganizationSettings; } });
+var table_user_settings_1 = require("./table-user-settings");
+Object.defineProperty(exports, "TableUserSettings", { enumerable: true, get: function () { return table_user_settings_1.TableUserSettings; } });

package/table/table-organization-settings.d.ts

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

package/table/table-organization-settings.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableOrganizationSettings = void 0;
+exports.TableOrganizationSettings = {
+    name: 'TableOrganizationSettings',
+    slug: 'table_organization_settings',
+    category: 'data',
+    display_name: 'Organization Settings',
+    description: 'Creates an organization settings table with standard business fields (legal_name, address fields). Uses AuthzEntityMembership for access control.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {}
+    },
+    tags: ['template', 'settings', 'membership', 'schema'],
+};

package/table/table-user-profiles.d.ts

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

package/table/table-user-profiles.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableUserProfiles = void 0;
+exports.TableUserProfiles = {
+    name: 'TableUserProfiles',
+    slug: 'table_user_profiles',
+    category: 'data',
+    display_name: 'User Profiles',
+    description: 'Creates a user profiles table with standard profile fields (profile_picture, bio, first_name, last_name, tags, desired). Uses AuthzDirectOwner for edit access and AuthzAllowAll for select.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {}
+    },
+    tags: ['template', 'settings', 'ownership', 'schema'],
+};

package/table/table-user-settings.d.ts

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

package/table/table-user-settings.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableUserSettings = void 0;
+exports.TableUserSettings = {
+    name: 'TableUserSettings',
+    slug: 'table_user_settings',
+    category: 'data',
+    display_name: 'User Settings',
+    description: 'Creates a user settings table for user-specific configuration. Uses AuthzDirectOwner for access control.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {}
+    },
+    tags: ['template', 'settings', 'ownership', 'schema'],
+};

package/types.d.ts

@@ -0,0 +1,61 @@
+/**
+ * JSON Schema type definition.
+ *
+ * Inline subset matching the shape used by schema-typescript in dev-utils.
+ * We copy it here to avoid an external dependency.
+ */
+export interface JSONSchema {
+    $schema?: string;
+    $ref?: string;
+    title?: string;
+    properties?: {
+        [key: string]: JSONSchema;
+    };
+    required?: string[];
+    type?: string | string[];
+    const?: string;
+    enum?: (string | number | boolean)[];
+    items?: JSONSchema | JSONSchema[];
+    $defs?: {
+        [key: string]: JSONSchema;
+    };
+    definitions?: {
+        [key: string]: JSONSchema;
+    };
+    additionalProperties?: boolean | JSONSchema;
+    anyOf?: JSONSchema[];
+    allOf?: JSONSchema[];
+    oneOf?: JSONSchema[];
+    description?: string;
+    default?: unknown;
+    [key: string]: unknown;
+    format?: string;
+}
+/**
+ * A single node type definition in the registry.
+ *
+ * Each node type describes a reusable building block for blueprints:
+ * authorization policies (Authz*), data behaviors (Data*), field
+ * constraints (Field*), relations (Relation*), views (View*), or
+ * table templates (Table*).
+ *
+ * All keys use snake_case to match the server-side SQL convention.
+ * The parameter_schema uses JSON Schema to describe the node's
+ * configuration shape — these keys are also snake_case.
+ */
+export interface NodeTypeDefinition {
+    /** PascalCase name, e.g. 'AuthzDirectOwner' */
+    name: string;
+    /** snake_case slug, e.g. 'authz_direct_owner' */
+    slug: string;
+    /** Category: authz | data | field | relation | view */
+    category: string;
+    /** Human-readable display name, e.g. 'Direct Ownership' */
+    display_name: string;
+    /** Description of what this node type does */
+    description: string;
+    /** JSON Schema defining the parameter shape (all keys are snake_case) */
+    parameter_schema: JSONSchema;
+    /** Tags for categorization and filtering */
+    tags: string[];
+}

package/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/view/index.d.ts

@@ -0,0 +1,5 @@
+export { ViewTableProjection } from './view-table-projection';
+export { ViewFilteredTable } from './view-filtered-table';
+export { ViewJoinedTables } from './view-joined-tables';
+export { ViewAggregated } from './view-aggregated';
+export { ViewComposite } from './view-composite';

package/view/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViewComposite = exports.ViewAggregated = exports.ViewJoinedTables = exports.ViewFilteredTable = exports.ViewTableProjection = void 0;
+var view_table_projection_1 = require("./view-table-projection");
+Object.defineProperty(exports, "ViewTableProjection", { enumerable: true, get: function () { return view_table_projection_1.ViewTableProjection; } });
+var view_filtered_table_1 = require("./view-filtered-table");
+Object.defineProperty(exports, "ViewFilteredTable", { enumerable: true, get: function () { return view_filtered_table_1.ViewFilteredTable; } });
+var view_joined_tables_1 = require("./view-joined-tables");
+Object.defineProperty(exports, "ViewJoinedTables", { enumerable: true, get: function () { return view_joined_tables_1.ViewJoinedTables; } });
+var view_aggregated_1 = require("./view-aggregated");
+Object.defineProperty(exports, "ViewAggregated", { enumerable: true, get: function () { return view_aggregated_1.ViewAggregated; } });
+var view_composite_1 = require("./view-composite");
+Object.defineProperty(exports, "ViewComposite", { enumerable: true, get: function () { return view_composite_1.ViewComposite; } });

package/view/view-aggregated.d.ts

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

package/view/view-aggregated.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViewAggregated = void 0;
+exports.ViewAggregated = {
+    name: 'ViewAggregated',
+    slug: 'view_aggregated',
+    category: 'view',
+    display_name: 'Aggregated View',
+    description: 'View with GROUP BY and aggregate functions. Useful for summary/reporting views.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "source_table_id": {
+                "type": "string",
+                "format": "uuid",
+                "description": "UUID of the source table"
+            },
+            "group_by_fields": {
+                "type": "array",
+                "items": {
+                    "type": "string"
+                },
+                "description": "Field names to group by"
+            },
+            "aggregates": {
+                "type": "array",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "function": {
+                            "type": "string",
+                            "enum": [
+                                "COUNT",
+                                "SUM",
+                                "AVG",
+                                "MIN",
+                                "MAX"
+                            ]
+                        },
+                        "field": {
+                            "type": "string",
+                            "description": "Field to aggregate (or * for COUNT)"
+                        },
+                        "alias": {
+                            "type": "string",
+                            "description": "Output column name"
+                        }
+                    },
+                    "required": [
+                        "function",
+                        "alias"
+                    ]
+                },
+                "description": "Array of aggregate specifications"
+            }
+        },
+        "required": [
+            "source_table_id",
+            "group_by_fields",
+            "aggregates"
+        ]
+    },
+    tags: ['view', 'aggregate', 'reporting'],
+};

package/view/view-composite.d.ts

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

package/view/view-composite.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViewComposite = void 0;
+exports.ViewComposite = {
+    name: 'ViewComposite',
+    slug: 'view_composite',
+    category: 'view',
+    display_name: 'Composite View',
+    description: 'Advanced view using composite AST for the query. Use when other node types are insufficient (CTEs, UNIONs, complex subqueries, etc.).',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "query_ast": {
+                "type": "object",
+                "description": "Composite SELECT query AST (JSONB)"
+            }
+        },
+        "required": [
+            "query_ast"
+        ]
+    },
+    tags: ['view', 'advanced', 'composite', 'ast'],
+};

package/view/view-filtered-table.d.ts

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

package/view/view-filtered-table.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViewFilteredTable = void 0;
+exports.ViewFilteredTable = {
+    name: 'ViewFilteredTable',
+    slug: 'view_filtered_table',
+    category: 'view',
+    display_name: 'Filtered Table',
+    description: 'Table projection with an Authz* filter baked into the view definition. The view only returns records matching the filter.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "source_table_id": {
+                "type": "string",
+                "format": "uuid",
+                "description": "UUID of the source table"
+            },
+            "filter_type": {
+                "type": "string",
+                "description": "Authz* node type name (e.g., AuthzDirectOwner, AuthzPublishable)"
+            },
+            "filter_data": {
+                "type": "object",
+                "description": "Parameters for the Authz* filter type"
+            },
+            "field_ids": {
+                "type": "array",
+                "items": {
+                    "type": "string",
+                    "format": "uuid"
+                },
+                "description": "Optional array of field UUIDs to include (alternative to field_names)"
+            },
+            "field_names": {
+                "type": "array",
+                "items": {
+                    "type": "string"
+                },
+                "description": "Optional array of field names to include (alternative to field_ids)"
+            }
+        },
+        "required": [
+            "source_table_id",
+            "filter_type"
+        ]
+    },
+    tags: ['view', 'filter', 'authz'],
+};

package/view/view-joined-tables.d.ts

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