node-type-registry 0.2.0

package/esm/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/esm/types.js

@@ -0,0 +1 @@
+export {};

package/esm/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/esm/view/index.js

@@ -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/esm/view/view-aggregated.d.ts

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

package/esm/view/view-aggregated.js

@@ -0,0 +1,61 @@
+export const 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/esm/view/view-composite.d.ts

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

package/esm/view/view-composite.js

@@ -0,0 +1,20 @@
+export const 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/esm/view/view-filtered-table.d.ts

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

package/esm/view/view-filtered-table.js

@@ -0,0 +1,45 @@
+export const 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/esm/view/view-joined-tables.d.ts

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

package/esm/view/view-joined-tables.js

@@ -0,0 +1,80 @@
+export const ViewJoinedTables = {
+    name: 'ViewJoinedTables',
+    slug: 'view_joined_tables',
+    category: 'view',
+    display_name: 'Joined Tables',
+    description: 'View that joins multiple tables together. Supports INNER, LEFT, RIGHT, and FULL joins.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "primary_table_id": {
+                "type": "string",
+                "format": "uuid",
+                "description": "UUID of the primary (left-most) table"
+            },
+            "primary_columns": {
+                "type": "array",
+                "items": {
+                    "type": "string"
+                },
+                "description": "Optional array of column names to include from the primary table"
+            },
+            "joins": {
+                "type": "array",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "table_id": {
+                            "type": "string",
+                            "format": "uuid",
+                            "description": "UUID of the joined table"
+                        },
+                        "join_type": {
+                            "type": "string",
+                            "enum": [
+                                "INNER",
+                                "LEFT",
+                                "RIGHT",
+                                "FULL"
+                            ]
+                        },
+                        "primary_field": {
+                            "type": "string",
+                            "description": "Field on primary table"
+                        },
+                        "join_field": {
+                            "type": "string",
+                            "description": "Field on joined table"
+                        },
+                        "columns": {
+                            "type": "array",
+                            "items": {
+                                "type": "string"
+                            },
+                            "description": "Optional column names to include from this joined table"
+                        }
+                    },
+                    "required": [
+                        "table_id",
+                        "primary_field",
+                        "join_field"
+                    ]
+                },
+                "description": "Array of join specifications"
+            },
+            "field_ids": {
+                "type": "array",
+                "items": {
+                    "type": "string",
+                    "format": "uuid"
+                },
+                "description": "Optional array of field UUIDs to include (alternative to per-table columns)"
+            }
+        },
+        "required": [
+            "primary_table_id",
+            "joins"
+        ]
+    },
+    tags: ['view', 'join'],
+};

package/esm/view/view-table-projection.d.ts

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

package/esm/view/view-table-projection.js

@@ -0,0 +1,36 @@
+export const ViewTableProjection = {
+    name: 'ViewTableProjection',
+    slug: 'view_table_projection',
+    category: 'view',
+    display_name: 'Table Projection',
+    description: 'Simple column selection from a single source table. Projects all or specific fields.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "source_table_id": {
+                "type": "string",
+                "format": "uuid",
+                "description": "UUID of the source table to project from"
+            },
+            "field_ids": {
+                "type": "array",
+                "items": {
+                    "type": "string",
+                    "format": "uuid"
+                },
+                "description": "Optional array of field UUIDs to include (all fields if omitted)"
+            },
+            "field_names": {
+                "type": "array",
+                "items": {
+                    "type": "string"
+                },
+                "description": "Optional array of field names to include (alternative to field_ids)"
+            }
+        },
+        "required": [
+            "source_table_id"
+        ]
+    },
+    tags: ['view', 'projection'],
+};

package/field/field-immutable.d.ts

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

package/field/field-immutable.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldImmutable = void 0;
+exports.FieldImmutable = {
+    name: 'FieldImmutable',
+    slug: 'field_immutable',
+    category: 'field',
+    display_name: 'Immutable',
+    description: 'Prevents a field from being modified after initial insert.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "field_id": {
+                "type": "string",
+                "format": "uuid",
+                "description": "UUID of the field that cannot be updated"
+            }
+        },
+        "required": [
+            "field_id"
+        ]
+    },
+    tags: ['constraint', 'behavior'],
+};

package/field/field-inflection.d.ts

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

package/field/field-inflection.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldInflection = void 0;
+exports.FieldInflection = {
+    name: 'FieldInflection',
+    slug: 'field_inflection',
+    category: 'field',
+    display_name: 'Inflection',
+    description: 'Transforms field values using inflection operations (snake_case, camelCase, etc).',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "field_id": {
+                "type": "string",
+                "format": "uuid",
+                "description": "Target field"
+            },
+            "ops": {
+                "type": "array",
+                "items": {
+                    "type": "string"
+                },
+                "description": "Inflection operations to apply"
+            }
+        },
+        "required": [
+            "field_id",
+            "ops"
+        ]
+    },
+    tags: ['transform', 'behavior'],
+};

package/field/field-owned.d.ts

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

package/field/field-owned.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldOwned = void 0;
+exports.FieldOwned = {
+    name: 'FieldOwned',
+    slug: 'field_owned',
+    category: 'field',
+    display_name: 'Owned',
+    description: 'Restricts which user can modify specific columns in shared objects. For tables where multiple users have access but each can only modify certain columns.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "table_id": {
+                "type": "string",
+                "format": "uuid",
+                "description": "Target table"
+            },
+            "role_key_field_id": {
+                "type": "string",
+                "format": "uuid",
+                "description": "Field identifying the owner (e.g., sender_id)"
+            },
+            "protected_field_ids": {
+                "type": "array",
+                "items": {
+                    "type": "string",
+                    "format": "uuid"
+                },
+                "description": "Fields only this owner can modify"
+            }
+        },
+        "required": [
+            "table_id",
+            "role_key_field_id",
+            "protected_field_ids"
+        ]
+    },
+    tags: ['ownership', 'constraint', 'behavior'],
+};

package/field/field-slug.d.ts

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

package/field/field-slug.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldSlug = void 0;
+exports.FieldSlug = {
+    name: 'FieldSlug',
+    slug: 'field_slug',
+    category: 'field',
+    display_name: 'Slug',
+    description: 'Auto-generates URL-friendly slugs from field values on insert/update.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "field_id": {
+                "type": "string",
+                "format": "uuid",
+                "description": "Target field to slugify"
+            },
+            "source_field_id": {
+                "type": "string",
+                "format": "uuid",
+                "description": "Optional source field (defaults to target)"
+            }
+        },
+        "required": [
+            "field_id"
+        ]
+    },
+    tags: ['transform', 'behavior'],
+};

package/field/index.d.ts

@@ -0,0 +1,4 @@
+export { FieldImmutable } from './field-immutable';
+export { FieldSlug } from './field-slug';
+export { FieldInflection } from './field-inflection';
+export { FieldOwned } from './field-owned';

package/field/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldOwned = exports.FieldInflection = exports.FieldSlug = exports.FieldImmutable = void 0;
+var field_immutable_1 = require("./field-immutable");
+Object.defineProperty(exports, "FieldImmutable", { enumerable: true, get: function () { return field_immutable_1.FieldImmutable; } });
+var field_slug_1 = require("./field-slug");
+Object.defineProperty(exports, "FieldSlug", { enumerable: true, get: function () { return field_slug_1.FieldSlug; } });
+var field_inflection_1 = require("./field-inflection");
+Object.defineProperty(exports, "FieldInflection", { enumerable: true, get: function () { return field_inflection_1.FieldInflection; } });
+var field_owned_1 = require("./field-owned");
+Object.defineProperty(exports, "FieldOwned", { enumerable: true, get: function () { return field_owned_1.FieldOwned; } });

package/index.d.ts

@@ -0,0 +1,9 @@
+export type { NodeTypeDefinition, JSONSchema } from './types';
+export * from './authz';
+export * from './data';
+export * from './field';
+export * from './relation';
+export * from './view';
+export * from './table';
+import type { NodeTypeDefinition } from './types';
+export declare const allNodeTypes: NodeTypeDefinition[];

package/index.js

@@ -0,0 +1,60 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allNodeTypes = void 0;
+// Re-export all node definitions by category
+__exportStar(require("./authz"), exports);
+__exportStar(require("./data"), exports);
+__exportStar(require("./field"), exports);
+__exportStar(require("./relation"), exports);
+__exportStar(require("./view"), exports);
+__exportStar(require("./table"), exports);
+const authz = __importStar(require("./authz"));
+const data = __importStar(require("./data"));
+const field = __importStar(require("./field"));
+const relation = __importStar(require("./relation"));
+const view = __importStar(require("./view"));
+const table = __importStar(require("./table"));
+exports.allNodeTypes = [
+    ...Object.values(authz),
+    ...Object.values(data),
+    ...Object.values(field),
+    ...Object.values(relation),
+    ...Object.values(view),
+    ...Object.values(table),
+];

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "node-type-registry",
+  "version": "0.2.0",
+  "description": "Node type definitions for the Constructive blueprint system. Single source of truth for all Authz*, Data*, Field*, Relation*, View*, and Table* node types.",
+  "author": "Constructive <developers@constructive.io>",
+  "main": "index.js",
+  "module": "esm/index.js",
+  "types": "index.d.ts",
+  "homepage": "https://github.com/constructive-io/constructive",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "directory": "dist"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/constructive-io/constructive"
+  },
+  "bugs": {
+    "url": "https://github.com/constructive-io/constructive/issues"
+  },
+  "scripts": {
+    "clean": "makage clean",
+    "prepack": "npm run build",
+    "build": "makage build",
+    "build:dev": "makage build --dev",
+    "lint": "eslint . --fix",
+    "test": "jest",
+    "test:watch": "jest --watch"
+  },
+  "dependencies": {
+    "@pgsql/types": "^17.6.2",
+    "@pgsql/utils": "^17.8.14",
+    "graphile-config": "1.0.0-rc.6",
+    "graphile-settings": "^4.14.0",
+    "pgsql-deparser": "^17.18.1"
+  },
+  "devDependencies": {
+    "makage": "^0.1.10"
+  },
+  "keywords": [
+    "constructive",
+    "blueprint",
+    "node-type",
+    "registry",
+    "graphile"
+  ],
+  "gitHead": "6eb4389816805b64af3a2aa18b29a08f37bb013f"
+}

package/preset.d.ts

@@ -0,0 +1,23 @@
+/**
+ * PostGraphile v5 Preset for Node Type Registry
+ *
+ * Opt-in preset that generates @oneOf typed GraphQL input types
+ * (BlueprintDefinitionInput, BlueprintNodeInput, etc.) from the
+ * TS node type definitions. Uses the existing createBlueprintTypesPlugin
+ * factory — no DB query needed.
+ *
+ * This preset is NOT included in ConstructivePreset (which is for all
+ * Constructive databases). It should only be layered on by the
+ * constructive-db SDK codegen or other consumers that need blueprint types.
+ *
+ * Usage:
+ *   import { NodeTypeRegistryPreset } from 'node-type-registry/preset';
+ *
+ *   const sdl = await buildSchemaSDL({
+ *     database: dbConfig.database,
+ *     schemas,
+ *     graphile: { extends: [NodeTypeRegistryPreset] },
+ *   });
+ */
+import type { GraphileConfig } from 'graphile-config';
+export declare const NodeTypeRegistryPreset: GraphileConfig.Preset;