node-type-registry 0.42.0 → 0.43.0

package/limit/enforce-counter.js

@@ -12,31 +12,54 @@ exports.LimitEnforceCounter = {
         properties: {
             limit_name: {
                 type: 'string',
-                description: 'Name of the limit to track (must match a default_limits entry, e.g. "projects", "members")',
+                description: 'Name of the limit to track (must match a default_limits entry, e.g. "projects", "members")'
             },
             scope: {
                 type: 'string',
-                enum: ['app', 'org'],
-                description: 'Limit scope: "app" (membership_type=1, user-level) or "org" (membership_type=2, entity-level)',
-                default: 'app',
+                description: 'Membership type prefix that determines which limits_module row to use. Resolved dynamically via memberships_module — supports any provisioned type (e.g. "app", "org", "data_room", "channel", "team").',
+                default: 'app'
             },
             actor_field: {
                 type: 'string',
                 format: 'column-ref',
                 description: 'Column on the target table that holds the actor or entity id used for limit lookup',
-                default: 'owner_id',
+                default: 'owner_id'
+            },
+            entity_field: {
+                type: 'string',
+                format: 'column-ref',
+                description: 'Column on the target table that holds (or references) the entity id for entity context resolution. For direct entity_id columns, just set this field. For FK lookups (e.g., channel_id → channels.entity_id), combine with entity_lookup.'
+            },
+            entity_lookup: {
+                type: 'object',
+                description: 'FK lookup configuration for resolving entity_id through a related table. Used when entity_field is a FK (e.g., channel_id) rather than a direct entity_id. The generator validates all fields against metaschema within the same database_id.',
+                properties: {
+                    obj_table: {
+                        type: 'string',
+                        description: 'Name of the related table to look up entity_id from (e.g., "channels"). Required.'
+                    },
+                    obj_schema: {
+                        type: 'string',
+                        description: 'Schema of the related table (user-facing name, e.g., "public"). Optional — if omitted, resolved by table name within the same database_id (raises error if ambiguous).'
+                    },
+                    obj_field: {
+                        type: 'string',
+                        description: 'Column on the related table that holds the entity_id (e.g., "entity_id"). Required.'
+                    }
+                },
+                required: ['obj_table', 'obj_field']
             },
             events: {
                 type: 'array',
                 items: {
                     type: 'string',
-                    enum: ['INSERT', 'DELETE', 'UPDATE'],
+                    enum: ['INSERT', 'DELETE', 'UPDATE']
                 },
                 description: 'Which DML events to attach triggers for',
-                default: ['INSERT', 'DELETE'],
-            },
+                default: ['INSERT', 'DELETE']
+            }
         },
-        required: ['limit_name'],
+        required: ['limit_name']
     },
-    tags: ['limits', 'triggers', 'enforce'],
+    tags: ['limits', 'triggers', 'enforce']
 };

package/limit/enforce-feature.js

@@ -12,22 +12,40 @@ exports.LimitEnforceFeature = {
         properties: {
             feature_name: {
                 type: 'string',
-                description: 'Cap name representing this feature (must match a limit_caps_defaults entry with max=0 or max=1)',
+                description: 'Cap name representing this feature (must match a limit_caps_defaults entry with max=0 or max=1)'
             },
             scope: {
                 type: 'string',
-                enum: ['app', 'org'],
-                description: 'Feature scope: "app" (membership_type=1, app-level caps) or "org" (membership_type=2, per-entity caps)',
-                default: 'app',
+                description: 'Membership type prefix that determines which limits_module row to use. Resolved dynamically via memberships_module — supports any provisioned type (e.g. "app", "org", "data_room", "channel", "team").',
+                default: 'app'
             },
             entity_field: {
                 type: 'string',
                 format: 'column-ref',
-                description: 'Column on the target table that holds the entity id for per-entity cap lookups (only used for org scope)',
-                default: 'entity_id',
+                description: 'Column on the target table that holds (or references) the entity id for per-entity cap lookups (only used for org scope). For FK lookups (e.g., channel_id → channels.entity_id), combine with entity_lookup.',
+                default: 'entity_id'
             },
+            entity_lookup: {
+                type: 'object',
+                description: 'FK lookup configuration for resolving entity_id through a related table. Used when entity_field is a FK (e.g., channel_id) rather than a direct entity_id. The generator validates all fields against metaschema within the same database_id.',
+                properties: {
+                    obj_table: {
+                        type: 'string',
+                        description: 'Name of the related table to look up entity_id from (e.g., "channels"). Required.'
+                    },
+                    obj_schema: {
+                        type: 'string',
+                        description: 'Schema of the related table (user-facing name, e.g., "public"). Optional — if omitted, resolved by table name within the same database_id (raises error if ambiguous).'
+                    },
+                    obj_field: {
+                        type: 'string',
+                        description: 'Column on the related table that holds the entity_id (e.g., "entity_id"). Required.'
+                    }
+                },
+                required: ['obj_table', 'obj_field']
+            }
         },
-        required: ['feature_name'],
+        required: ['feature_name']
     },
-    tags: ['limits', 'triggers', 'feature-flags', 'enforce', 'caps'],
+    tags: ['limits', 'triggers', 'feature-flags', 'enforce', 'caps']
 };

package/limit/enforce-rate.js

@@ -12,31 +12,50 @@ exports.LimitEnforceRate = {
         properties: {
             meter_slug: {
                 type: 'string',
-                description: 'Slug of the billing meter to check rate limits against (must match a meters table entry, e.g. "messaging", "inference")',
+                description: 'Slug of the billing meter to check rate limits against (must match a meters table entry, e.g. "messaging", "inference")'
             },
             entity_field: {
                 type: 'string',
                 format: 'column-ref',
-                description: 'Column on the target table that holds the entity id (org) for rate limiting',
-                default: 'entity_id',
+                description: 'Column on the target table that holds (or references) the entity id for rate limiting. For direct entity_id columns, just set this field. For FK lookups (e.g., channel_id → channels.entity_id), combine with entity_lookup.',
+                default: 'entity_id'
+            },
+            entity_lookup: {
+                type: 'object',
+                description: 'FK lookup configuration for resolving entity_id through a related table. Used when entity_field is a FK (e.g., channel_id) rather than a direct entity_id. The generator validates all fields against metaschema within the same database_id.',
+                properties: {
+                    obj_table: {
+                        type: 'string',
+                        description: 'Name of the related table to look up entity_id from (e.g., "channels"). Required.'
+                    },
+                    obj_schema: {
+                        type: 'string',
+                        description: 'Schema of the related table (user-facing name, e.g., "public"). Optional — if omitted, resolved by table name within the same database_id (raises error if ambiguous).'
+                    },
+                    obj_field: {
+                        type: 'string',
+                        description: 'Column on the related table that holds the entity_id (e.g., "entity_id"). Required.'
+                    }
+                },
+                required: ['obj_table', 'obj_field']
             },
             actor_field: {
                 type: 'string',
                 format: 'column-ref',
                 description: 'Column on the target table that holds the actor id (user) for rate limiting',
-                default: 'owner_id',
+                default: 'owner_id'
             },
             events: {
                 type: 'array',
                 items: {
                     type: 'string',
-                    enum: ['INSERT', 'UPDATE'],
+                    enum: ['INSERT', 'UPDATE']
                 },
                 description: 'Which DML events to enforce rate limits on (DELETE is excluded since it reduces load)',
-                default: ['INSERT'],
-            },
+                default: ['INSERT']
+            }
         },
-        required: ['meter_slug'],
+        required: ['meter_slug']
     },
-    tags: ['rate-limits', 'triggers', 'enforce', 'metering', 'abuse-protection'],
+    tags: ['rate-limits', 'triggers', 'enforce', 'metering', 'abuse-protection']
 };

package/limit/track-usage.js

@@ -12,30 +12,49 @@ exports.LimitTrackUsage = {
         properties: {
             meter_slug: {
                 type: 'string',
-                description: 'Slug of the billing meter to record usage against (must match a meters table entry, e.g. "databases", "seats")',
+                description: 'Slug of the billing meter to record usage against (must match a meters table entry, e.g. "databases", "seats")'
             },
             entity_field: {
                 type: 'string',
                 format: 'column-ref',
-                description: 'Column on the target table that holds the entity id for billing',
-                default: 'entity_id',
+                description: 'Column on the target table that holds (or references) the entity id for billing. For direct entity_id columns, just set this field. For FK lookups (e.g., channel_id → channels.entity_id), combine with entity_lookup.',
+                default: 'entity_id'
+            },
+            entity_lookup: {
+                type: 'object',
+                description: 'FK lookup configuration for resolving entity_id through a related table. Used when entity_field is a FK (e.g., channel_id) rather than a direct entity_id. The generator validates all fields against metaschema within the same database_id.',
+                properties: {
+                    obj_table: {
+                        type: 'string',
+                        description: 'Name of the related table to look up entity_id from (e.g., "channels"). Required.'
+                    },
+                    obj_schema: {
+                        type: 'string',
+                        description: 'Schema of the related table (user-facing name, e.g., "public"). Optional — if omitted, resolved by table name within the same database_id (raises error if ambiguous).'
+                    },
+                    obj_field: {
+                        type: 'string',
+                        description: 'Column on the related table that holds the entity_id (e.g., "entity_id"). Required.'
+                    }
+                },
+                required: ['obj_table', 'obj_field']
             },
             quantity: {
                 type: 'integer',
                 description: 'Units to record per event (default 1)',
-                default: 1,
+                default: 1
             },
             events: {
                 type: 'array',
                 items: {
                     type: 'string',
-                    enum: ['INSERT', 'DELETE', 'UPDATE'],
+                    enum: ['INSERT', 'DELETE', 'UPDATE']
                 },
                 description: 'Which DML events to attach triggers for',
-                default: ['INSERT', 'DELETE'],
-            },
+                default: ['INSERT', 'DELETE']
+            }
         },
-        required: ['meter_slug'],
+        required: ['meter_slug']
     },
-    tags: ['billing', 'triggers', 'metering', 'usage', 'track'],
+    tags: ['billing', 'triggers', 'metering', 'usage', 'track']
 };

package/limit/warning-aggregate.js

@@ -12,16 +12,40 @@ exports.LimitWarningAggregate = {
         properties: {
             limit_name: {
                 type: 'string',
-                description: 'Name of the aggregate limit to watch (must match a limit_warnings.name entry, e.g. "databases", "members")',
+                description: 'Name of the aggregate limit to watch (must match a limit_warnings.name entry, e.g. "databases", "members")'
+            },
+            scope: {
+                type: 'string',
+                description: 'Membership type prefix that determines which limits_module row to use. Resolved dynamically via memberships_module — supports any provisioned type (e.g. "org", "data_room", "channel", "team").',
+                default: 'org'
             },
             entity_field: {
                 type: 'string',
                 format: 'column-ref',
-                description: 'Column on the target table that holds the entity id for aggregate limit lookup',
-                default: 'entity_id',
+                description: 'Column on the target table that holds (or references) the entity id for aggregate limit lookup. For direct entity_id columns, just set this field. For FK lookups (e.g., channel_id → channels.entity_id), combine with entity_lookup.',
+                default: 'entity_id'
             },
+            entity_lookup: {
+                type: 'object',
+                description: 'FK lookup configuration for resolving entity_id through a related table. Used when entity_field is a FK (e.g., channel_id) rather than a direct entity_id. The generator validates all fields against metaschema within the same database_id.',
+                properties: {
+                    obj_table: {
+                        type: 'string',
+                        description: 'Name of the related table to look up entity_id from (e.g., "channels"). Required.'
+                    },
+                    obj_schema: {
+                        type: 'string',
+                        description: 'Schema of the related table (user-facing name, e.g., "public"). Optional — if omitted, resolved by table name within the same database_id (raises error if ambiguous).'
+                    },
+                    obj_field: {
+                        type: 'string',
+                        description: 'Column on the related table that holds the entity_id (e.g., "entity_id"). Required.'
+                    }
+                },
+                required: ['obj_table', 'obj_field']
+            }
         },
-        required: ['limit_name'],
+        required: ['limit_name']
     },
-    tags: ['limits', 'triggers', 'aggregates', 'warning', 'notifications'],
+    tags: ['limits', 'triggers', 'aggregates', 'warning', 'notifications']
 };

package/limit/warning-counter.js

@@ -12,22 +12,45 @@ exports.LimitWarningCounter = {
         properties: {
             limit_name: {
                 type: 'string',
-                description: 'Name of the limit to watch (must match a limit_warnings.name entry, e.g. "projects", "members")',
+                description: 'Name of the limit to watch (must match a limit_warnings.name entry, e.g. "projects", "members")'
             },
             scope: {
                 type: 'string',
-                enum: ['app', 'org'],
-                description: 'Limit scope: "app" (membership_type=1, user-level) or "org" (membership_type=2, entity-level)',
-                default: 'app',
+                description: 'Membership type prefix that determines which limits_module row to use. Resolved dynamically via memberships_module — supports any provisioned type (e.g. "app", "org", "data_room", "channel", "team").',
+                default: 'app'
             },
             actor_field: {
                 type: 'string',
                 format: 'column-ref',
                 description: 'Column on the target table that holds the actor id for limit lookup',
-                default: 'owner_id',
+                default: 'owner_id'
             },
+            entity_field: {
+                type: 'string',
+                format: 'column-ref',
+                description: 'Column on the target table that holds (or references) the entity id. When provided, entity_id is included in the job payload and dedup state. For FK lookups (e.g., channel_id → channels.entity_id), combine with entity_lookup.'
+            },
+            entity_lookup: {
+                type: 'object',
+                description: 'FK lookup configuration for resolving entity_id through a related table. Used when entity_field is a FK (e.g., channel_id) rather than a direct entity_id. The generator validates all fields against metaschema within the same database_id.',
+                properties: {
+                    obj_table: {
+                        type: 'string',
+                        description: 'Name of the related table to look up entity_id from (e.g., "channels"). Required.'
+                    },
+                    obj_schema: {
+                        type: 'string',
+                        description: 'Schema of the related table (user-facing name, e.g., "public"). Optional — if omitted, resolved by table name within the same database_id (raises error if ambiguous).'
+                    },
+                    obj_field: {
+                        type: 'string',
+                        description: 'Column on the related table that holds the entity_id (e.g., "entity_id"). Required.'
+                    }
+                },
+                required: ['obj_table', 'obj_field']
+            }
         },
-        required: ['limit_name'],
+        required: ['limit_name']
     },
-    tags: ['limits', 'triggers', 'warning', 'notifications'],
+    tags: ['limits', 'triggers', 'warning', 'notifications']
 };

package/limit/warning-rate.js

@@ -12,22 +12,46 @@ exports.LimitWarningRate = {
         properties: {
             meter_slug: {
                 type: 'string',
-                description: 'Slug of the billing meter to check rate limits against (must match a meters table entry)',
+                description: 'Slug of the billing meter to check rate limits against (must match a meters table entry)'
+            },
+            scope: {
+                type: 'string',
+                description: 'Membership type prefix that determines which limits_module row to use for warnings and warning_state tables. Resolved dynamically via memberships_module — supports any provisioned type (e.g. "app", "org", "data_room", "channel", "team").',
+                default: 'app'
             },
             entity_field: {
                 type: 'string',
                 format: 'column-ref',
-                description: 'Column on the target table that holds the entity id for rate limit lookup',
-                default: 'entity_id',
+                description: 'Column on the target table that holds (or references) the entity id for rate limit lookup. For direct entity_id columns, just set this field. For FK lookups (e.g., channel_id → channels.entity_id), combine with entity_lookup.',
+                default: 'entity_id'
+            },
+            entity_lookup: {
+                type: 'object',
+                description: 'FK lookup configuration for resolving entity_id through a related table. Used when entity_field is a FK (e.g., channel_id) rather than a direct entity_id. The generator validates all fields against metaschema within the same database_id.',
+                properties: {
+                    obj_table: {
+                        type: 'string',
+                        description: 'Name of the related table to look up entity_id from (e.g., "channels"). Required.'
+                    },
+                    obj_schema: {
+                        type: 'string',
+                        description: 'Schema of the related table (user-facing name, e.g., "public"). Optional — if omitted, resolved by table name within the same database_id (raises error if ambiguous).'
+                    },
+                    obj_field: {
+                        type: 'string',
+                        description: 'Column on the related table that holds the entity_id (e.g., "entity_id"). Required.'
+                    }
+                },
+                required: ['obj_table', 'obj_field']
             },
             actor_field: {
                 type: 'string',
                 format: 'column-ref',
                 description: 'Column on the target table that holds the actor id for rate limit lookup',
-                default: 'owner_id',
-            },
+                default: 'owner_id'
+            }
         },
-        required: ['meter_slug'],
+        required: ['meter_slug']
     },
-    tags: ['rate-limits', 'triggers', 'warning', 'notifications', 'metering'],
+    tags: ['rate-limits', 'triggers', 'warning', 'notifications', 'metering']
 };

package/module-presets/full.js

@@ -79,7 +79,7 @@ exports.PresetFull = {
         'user_auth_module',
         'webauthn_auth_module',
         // Storage (full features)
-        'storage_module:full',
+        'storage_module:full'
     ],
     includes_notes: {
         'storage_module:full': 'All storage feature flags enabled: versioning, content hash, custom keys, audit log.',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-type-registry",
-  "version": "0.42.0",
+  "version": "0.43.0",
   "description": "Node type definitions for the Constructive blueprint system. Single source of truth for all Authz*, Data*, Relation*, and View* node types.",
   "author": "Constructive <developers@constructive.io>",
   "main": "index.js",
@@ -47,5 +47,5 @@
     "registry",
     "graphile"
   ],
-  "gitHead": "72ffa0944cbf0386b9f2f5dfd6640879bb30e38d"
+  "gitHead": "c9317afa5b5c2401ab1a18c927c3fd75b59a0b01"
 }

package/process/chunks.js

@@ -80,7 +80,7 @@ exports.ProcessChunks = {
             // ── Table naming ───────────────────────────────────────────────
             chunks_table_name: {
                 type: 'string',
-                description: 'Override the chunks table name. Defaults to {parent_table}_chunks.',
+                description: 'Override the chunks table name. Defaults to {parent_table}_chunks.'
             },
             // ── Metadata ───────────────────────────────────────────────────
             metadata_fields: {

package/process/file-embedding.js

@@ -135,7 +135,7 @@ exports.ProcessFileEmbedding = {
                 type: 'boolean',
                 description: 'Whether to create a chunks table via ProcessChunks. Defaults to true ' +
                     'when extraction is provided, false in direct mode. Set explicitly ' +
-                    'to override.',
+                    'to override.'
             },
             chunks: {
                 type: 'object',

package/types.d.ts

@@ -1,3 +1,95 @@
+/**
+ * Structured representation of a PostgreSQL data type.
+ *
+ * Stored as JSONB in `metaschema_public.field.type`.
+ *
+ * @example Simple type
+ * { name: "text" }
+ *
+ * @example Type with arguments
+ * { name: "geometry", args: ["Point", 4326] }
+ * { name: "numeric", args: [10, 2] }
+ * { name: "vector", args: [1536] }
+ *
+ * @example Array type
+ * { name: "text", array_dimensions: 1 }
+ *
+ * @example Schema-qualified type
+ * { name: "my_type", schema: "my_schema" }
+ *
+ * @example Interval with field range
+ * { name: "interval", range: ["day", "second"] }
+ */
+export interface FieldType {
+    /** Type name (required). Must be a valid SQL identifier. */
+    name: string;
+    /** Schema qualifier (optional). Must be a valid SQL identifier. */
+    schema?: string;
+    /** Type arguments (optional). Each is a string identifier, number, or boolean. */
+    args?: (string | number | boolean)[];
+    /** Number of array dimensions (optional). 1 = `text[]`, 2 = `text[][]`. */
+    array_dimensions?: number;
+    /** Interval field range (optional). 1-2 elements: ["day"] or ["day", "second"]. */
+    range?: string[];
+}
+/**
+ * Argument to a function in a FieldDefault expression.
+ * Can be a literal value or a nested FieldDefault (recursive).
+ */
+export type FieldDefaultArg = string | number | boolean | null | FieldDefault;
+/**
+ * Structured representation of a PostgreSQL default value expression.
+ *
+ * Stored as JSONB in `metaschema_public.field.default_value`.
+ *
+ * @example Literal values
+ * { value: false }
+ * { value: 0 }
+ * { value: "pooled" }
+ *
+ * @example Cast expression
+ * { value: {}, cast: { name: "jsonb" } }
+ * { value: "15 minutes", cast: { name: "interval" } }
+ *
+ * @example Simple function call
+ * { function: "now" }
+ * { function: "gen_random_uuid" }
+ *
+ * @example Schema-qualified function
+ * { function: "current_user_id", schema: "jwt_public" }
+ *
+ * @example Function with arguments (nested)
+ * { function: "encode", args: [{ function: "gen_random_bytes", args: [{ value: 16 }] }, { value: "hex" }] }
+ *
+ * @example Function with cast
+ * { function: "lpad", args: [{ value: "" }, { value: 32 }, { value: "0" }], cast: { name: "bit", args: [32] } }
+ *
+ * @example Operator expression
+ * { operator: "+", left: { function: "now" }, right: { value: "5 minutes", cast: { name: "interval" } } }
+ *
+ * @example SQL keyword
+ * { sql_keyword: "CURRENT_TIMESTAMP" }
+ */
+export interface FieldDefault {
+    /** Literal value (string, number, boolean, null, array, or object). */
+    value?: string | number | boolean | null | unknown[] | Record<string, unknown>;
+    /** Function name. Must be a valid SQL identifier. */
+    function?: string;
+    /** Schema qualifier for function (optional). */
+    schema?: string;
+    /** Function arguments (optional, recursive). */
+    args?: FieldDefaultArg[];
+    /** Output type cast (optional). Reuses FieldType shape. */
+    cast?: FieldType;
+    /** Binary operator (e.g., "+", "-", "||"). */
+    operator?: string;
+    /** Left operand for operator expression. */
+    left?: FieldDefault;
+    /** Right operand for operator expression. */
+    right?: FieldDefault;
+    /** SQL keyword (e.g., "CURRENT_TIMESTAMP", "CURRENT_USER"). */
+    sql_keyword?: string;
+}
 /**
  * JSON Schema type definition.
  *

package/types.js

@@ -1,2 +1,3 @@
 "use strict";
+// ─── FieldType / FieldDefault ─────────────────────────────────────
 Object.defineProperty(exports, "__esModule", { value: true });