node-type-registry 0.2.0

package/esm/data/data-timestamps.js

@@ -0,0 +1,18 @@
+export const 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/esm/data/data-trgm.d.ts

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

package/esm/data/data-trgm.js

@@ -0,0 +1,23 @@
+export const 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/esm/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/esm/data/index.js

@@ -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/esm/field/field-immutable.d.ts

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

package/esm/field/field-immutable.js

@@ -0,0 +1,21 @@
+export const 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/esm/field/field-inflection.d.ts

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

package/esm/field/field-inflection.js

@@ -0,0 +1,29 @@
+export const 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/esm/field/field-owned.d.ts

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

package/esm/field/field-owned.js

@@ -0,0 +1,36 @@
+export const 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/esm/field/field-slug.d.ts

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

package/esm/field/field-slug.js

@@ -0,0 +1,26 @@
+export const 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/esm/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/esm/field/index.js

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

@@ -0,0 +1,21 @@
+// Re-export all node definitions by category
+export * from './authz';
+export * from './data';
+export * from './field';
+export * from './relation';
+export * from './view';
+export * from './table';
+import * as authz from './authz';
+import * as data from './data';
+import * as field from './field';
+import * as relation from './relation';
+import * as view from './view';
+import * as table from './table';
+export const allNodeTypes = [
+    ...Object.values(authz),
+    ...Object.values(data),
+    ...Object.values(field),
+    ...Object.values(relation),
+    ...Object.values(view),
+    ...Object.values(table),
+];

package/esm/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;

package/esm/preset.js

@@ -0,0 +1,5 @@
+import { createBlueprintTypesPlugin } from 'graphile-settings/plugins/blueprint-types/plugin';
+import { allNodeTypes } from './index';
+export const NodeTypeRegistryPreset = {
+    plugins: [createBlueprintTypesPlugin(allNodeTypes)],
+};

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

@@ -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/esm/relation/relation-belongs-to.d.ts

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

package/esm/relation/relation-belongs-to.js

@@ -0,0 +1,48 @@
+export const 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/esm/relation/relation-has-many.d.ts

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

package/esm/relation/relation-has-many.js

@@ -0,0 +1,48 @@
+export const 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/esm/relation/relation-has-one.d.ts

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

package/esm/relation/relation-has-one.js

@@ -0,0 +1,48 @@
+export const 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/esm/relation/relation-many-to-many.d.ts

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

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

@@ -0,0 +1,92 @@
+export const 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/esm/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/esm/table/index.js

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

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

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

package/esm/table/table-organization-settings.js

@@ -0,0 +1,12 @@
+export const 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/esm/table/table-user-profiles.d.ts

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

package/esm/table/table-user-profiles.js

@@ -0,0 +1,12 @@
+export const 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/esm/table/table-user-settings.d.ts

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

package/esm/table/table-user-settings.js

@@ -0,0 +1,12 @@
+export const 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'],
+};