node-type-registry 0.42.0 → 0.43.0

package/esm/blueprint-types.generated.d.ts

@@ -20,6 +20,40 @@ export interface TriggerCondition {
     /** Negated condition. */
     NOT?: TriggerCondition;
 }
+/** Structured representation of a PostgreSQL data type. Stored as JSONB in metaschema_public.field.type. */
+export interface FieldType {
+    /** Type name. Must be a valid SQL identifier. */
+    name: string;
+    /** Schema qualifier. */
+    schema?: string;
+    /** Type arguments (e.g., [10, 2] for numeric(10,2), ["Point", 4326] for geometry). */
+    args?: (string | number | boolean)[];
+    /** Number of array dimensions. 1 = text[], 2 = text[][]. */
+    array_dimensions?: number;
+    /** Interval field range. 1-2 elements: ["day"] or ["day", "second"]. */
+    range?: string[];
+}
+/** Structured representation of a PostgreSQL default value expression. Stored as JSONB in metaschema_public.field.default_value. */
+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. */
+    schema?: string;
+    /** Function arguments (recursive). */
+    args?: (string | number | boolean | null | FieldDefault)[];
+    /** Output type cast. */
+    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;
+}
 /** Adds a CHECK constraint that validates a column value is greater than a threshold (single-column: column > value) or that one column is greater than another (cross-column: columns[0] > columns[1]). Compiled via AST helpers. */
 export interface CheckGreaterThanParams {
     column?: string;
@@ -95,7 +129,7 @@ export interface DataInheritFromParentParams {
 /** Adds a JSONB column with optional GIN index for containment queries (@>, ?, ?|, ?&). Standard pattern for semi-structured metadata. */
 export interface DataJsonbParams {
     field_name?: string;
-    default_value?: string;
+    default_value?: FieldDefault;
     is_required?: boolean;
     create_index?: boolean;
 }
@@ -154,7 +188,7 @@ export interface DataSoftDeleteParams {
 /** Adds a status column with B-tree index for efficient equality filtering and sorting. Optionally constrains values via CHECK constraint when allowed_values is provided. */
 export interface DataStatusFieldParams {
     field_name?: string;
-    type?: string;
+    type?: FieldType;
     default_value?: string;
     is_required?: boolean;
     allowed_values?: string[];
@@ -162,7 +196,7 @@ export interface DataStatusFieldParams {
 /** Adds a citext[] tags column with GIN index for efficient array containment queries (@>, &&). Standard tagging pattern for categorization and filtering. */
 export interface DataTagsParams {
     field_name?: string;
-    default_value?: string;
+    default_value?: FieldDefault;
     is_required?: boolean;
 }
 /** Adds automatic timestamp tracking with created_at and updated_at columns. */
@@ -183,6 +217,11 @@ export interface EventReferralParams {
     events?: ('INSERT' | 'UPDATE' | 'DELETE')[];
     actor_field?: string;
     entity_field?: string;
+    entity_lookup?: {
+        obj_table: string;
+        obj_schema?: string;
+        obj_field: string;
+    };
     max_depth?: number;
     auto_register_type?: boolean;
     condition_field?: string;
@@ -198,6 +237,11 @@ export interface EventTrackerParams {
     toggle?: boolean;
     actor_field?: string;
     entity_field?: string;
+    entity_lookup?: {
+        obj_table: string;
+        obj_schema?: string;
+        obj_field: string;
+    };
     auto_register_type?: boolean;
     condition_field?: string;
     condition_value?: string;
@@ -207,26 +251,48 @@ export interface EventTrackerParams {
 /** Declaratively attaches aggregate limit-tracking triggers to a table. On INSERT the named limit is incremented per entity; on DELETE it is decremented. Uses org_limit_aggregates_inc/dec for per-entity (org-level) aggregate limits rather than per-user limits. Requires a provisioned limits_module for the target database. */
 export interface LimitEnforceAggregateParams {
     limit_name: string;
+    scope?: string;
     entity_field?: string;
+    entity_lookup?: {
+        obj_table: string;
+        obj_schema?: string;
+        obj_field: string;
+    };
     events?: ('INSERT' | 'DELETE' | 'UPDATE')[];
 }
 /** Declaratively attaches limit-tracking triggers to a table. On INSERT the named limit is incremented; on DELETE it is decremented. Requires a provisioned limits_module for the target scope. */
 export interface LimitEnforceCounterParams {
     limit_name: string;
-    scope?: 'app' | 'org';
+    scope?: string;
     actor_field?: string;
+    entity_field?: string;
+    entity_lookup?: {
+        obj_table: string;
+        obj_schema?: string;
+        obj_field: string;
+    };
     events?: ('INSERT' | 'DELETE' | 'UPDATE')[];
 }
 /** Gates a table behind a feature flag backed by the cap tables. Attaches a BEFORE INSERT trigger that checks whether the named feature cap value is > 0. Features are modeled as caps with max=0 (disabled) or max=1 (enabled) in limit_caps / limit_caps_defaults tables. Resolution: COALESCE(per-entity cap, scope default, 0). */
 export interface LimitEnforceFeatureParams {
     feature_name: string;
-    scope?: 'app' | 'org';
+    scope?: string;
     entity_field?: string;
+    entity_lookup?: {
+        obj_table: string;
+        obj_schema?: string;
+        obj_field: string;
+    };
 }
 /** Attaches a BEFORE trigger that calls check_rate_limit() to enforce sliding-window rate limits before allowing mutations. The function checks all three scopes (entity, actor-in-entity, actor) in a single call; which scopes are actually enforced is controlled by what rows exist in rate_window_limits (plan-based config). Requires a provisioned meter_rate_limits_module and billing_module for the target database. */
 export interface LimitEnforceRateParams {
     meter_slug: string;
     entity_field?: string;
+    entity_lookup?: {
+        obj_table: string;
+        obj_schema?: string;
+        obj_field: string;
+    };
     actor_field?: string;
     events?: ('INSERT' | 'UPDATE')[];
 }
@@ -234,24 +300,47 @@ export interface LimitEnforceRateParams {
 export interface LimitTrackUsageParams {
     meter_slug: string;
     entity_field?: string;
+    entity_lookup?: {
+        obj_table: string;
+        obj_schema?: string;
+        obj_field: string;
+    };
     quantity?: number;
     events?: ('INSERT' | 'DELETE' | 'UPDATE')[];
 }
 /** Attaches an AFTER INSERT trigger that checks if the entity's aggregate usage has crossed any warning threshold configured in the limit_warnings table. If a threshold is reached for the first time, enqueues a background job (e.g. email notification). Uses limit_warning_state for one-time dedup per warning/actor/entity triple. Requires a provisioned limits_module with limit_warnings and aggregate limits enabled. */
 export interface LimitWarningAggregateParams {
     limit_name: string;
+    scope?: string;
     entity_field?: string;
+    entity_lookup?: {
+        obj_table: string;
+        obj_schema?: string;
+        obj_field: string;
+    };
 }
 /** Attaches an AFTER INSERT trigger that checks if the actor's current usage has crossed any warning threshold configured in the limit_warnings table. If a threshold is reached for the first time, enqueues a background job (e.g. email notification). Uses limit_warning_state for one-time dedup per warning/actor pair. Requires a provisioned limits_module with limit_warnings enabled. */
 export interface LimitWarningCounterParams {
     limit_name: string;
-    scope?: 'app' | 'org';
+    scope?: string;
     actor_field?: string;
+    entity_field?: string;
+    entity_lookup?: {
+        obj_table: string;
+        obj_schema?: string;
+        obj_field: string;
+    };
 }
 /** Attaches an AFTER INSERT trigger that checks if the actor's current request count in the active sliding window has crossed any warning threshold configured in the limit_warnings table. If a threshold is reached for the first time, enqueues a background job (e.g. email notification). Uses limit_warning_state for one-time dedup per warning/actor pair. Requires both a limits_module with limit_warnings enabled and a rate_limit_meters_module. */
 export interface LimitWarningRateParams {
     meter_slug: string;
+    scope?: string;
     entity_field?: string;
+    entity_lookup?: {
+        obj_table: string;
+        obj_schema?: string;
+        obj_field: string;
+    };
     actor_field?: string;
 }
 /** Creates a BM25 index on an existing text column using pg_textsearch. Enables statistical relevance ranking with configurable k1 and b parameters. The BM25 index is auto-detected by graphile-search. */
@@ -804,12 +893,12 @@ export interface ViewTableProjectionParams {
 export interface BlueprintField {
     /** The column name. */
     name: string;
-    /** The PostgreSQL type (e.g., "text", "integer", "boolean", "uuid"). */
-    type: string;
+    /** PostgreSQL type as a FieldType object (e.g., { name: "text" }) or legacy string. */
+    type: FieldType | string;
     /** Whether the column has a NOT NULL constraint. */
     is_required?: boolean;
-    /** SQL default value expression (e.g., "true", "now()"). */
-    default_value?: string;
+    /** Default value as a FieldDefault object (e.g., { function: "now" }) or legacy string. */
+    default_value?: FieldDefault | string;
     /** Comment/description for this field. */
     description?: string;
 }

package/esm/codegen/generate-types.js

@@ -137,6 +137,56 @@ function buildTriggerConditionInterface() {
     ]), 'Recursive condition type for compound trigger WHEN clauses. Leaf conditions specify {field, op, value?, row?, ref?}. Combinators nest via AND, OR, NOT.');
 }
 // ---------------------------------------------------------------------------
+// FieldType — structured PostgreSQL type representation.
+// ---------------------------------------------------------------------------
+function buildFieldTypeInterface() {
+    const argType = t.tsUnionType([
+        t.tsStringKeyword(),
+        t.tsNumberKeyword(),
+        t.tsBooleanKeyword()
+    ]);
+    return addJSDoc(exportInterface('FieldType', [
+        addJSDoc(requiredProp('name', t.tsStringKeyword()), 'Type name. Must be a valid SQL identifier.'),
+        addJSDoc(optionalProp('schema', t.tsStringKeyword()), 'Schema qualifier.'),
+        addJSDoc(optionalProp('args', t.tsArrayType(argType)), 'Type arguments (e.g., [10, 2] for numeric(10,2), ["Point", 4326] for geometry).'),
+        addJSDoc(optionalProp('array_dimensions', t.tsNumberKeyword()), 'Number of array dimensions. 1 = text[], 2 = text[][].'),
+        addJSDoc(optionalProp('range', t.tsArrayType(t.tsStringKeyword())), 'Interval field range. 1-2 elements: ["day"] or ["day", "second"].')
+    ]), 'Structured representation of a PostgreSQL data type. Stored as JSONB in metaschema_public.field.type.');
+}
+// ---------------------------------------------------------------------------
+// FieldDefault — structured PostgreSQL default value expression.
+// ---------------------------------------------------------------------------
+function buildFieldDefaultInterface() {
+    const defaultRef = t.tsTypeReference(t.identifier('FieldDefault'));
+    const fieldTypeRef = t.tsTypeReference(t.identifier('FieldType'));
+    const valueType = t.tsUnionType([
+        t.tsStringKeyword(),
+        t.tsNumberKeyword(),
+        t.tsBooleanKeyword(),
+        t.tsNullKeyword(),
+        t.tsArrayType(t.tsUnknownKeyword()),
+        recordType(t.tsStringKeyword(), t.tsUnknownKeyword())
+    ]);
+    const argType = t.tsUnionType([
+        t.tsStringKeyword(),
+        t.tsNumberKeyword(),
+        t.tsBooleanKeyword(),
+        t.tsNullKeyword(),
+        defaultRef
+    ]);
+    return addJSDoc(exportInterface('FieldDefault', [
+        addJSDoc(optionalProp('value', valueType), 'Literal value (string, number, boolean, null, array, or object).'),
+        addJSDoc(optionalProp('function', t.tsStringKeyword()), 'Function name. Must be a valid SQL identifier.'),
+        addJSDoc(optionalProp('schema', t.tsStringKeyword()), 'Schema qualifier for function.'),
+        addJSDoc(optionalProp('args', t.tsArrayType(argType)), 'Function arguments (recursive).'),
+        addJSDoc(optionalProp('cast', fieldTypeRef), 'Output type cast.'),
+        addJSDoc(optionalProp('operator', t.tsStringKeyword()), 'Binary operator (e.g., "+", "-", "||").'),
+        addJSDoc(optionalProp('left', defaultRef), 'Left operand for operator expression.'),
+        addJSDoc(optionalProp('right', defaultRef), 'Right operand for operator expression.'),
+        addJSDoc(optionalProp('sql_keyword', t.tsStringKeyword()), 'SQL keyword (e.g., "CURRENT_TIMESTAMP", "CURRENT_USER").')
+    ]), 'Structured representation of a PostgreSQL default value expression. Stored as JSONB in metaschema_public.field.default_value.');
+}
+// ---------------------------------------------------------------------------
 // x-codegen-type post-processing — replaces properties that have an
 // 'x-codegen-type' marker in their JSON Schema with a hand-written TS type
 // reference.  This lets node type definitions delegate complex types
@@ -302,11 +352,13 @@ function buildBlueprintField(meta) {
         return deriveInterfaceFromTable(table, 'BlueprintField', 'A custom field (column) to add to a blueprint table. Derived from _meta.');
     }
     // Static fallback
+    const fieldTypeRef = t.tsTypeReference(t.identifier('FieldType'));
+    const fieldDefaultRef = t.tsTypeReference(t.identifier('FieldDefault'));
     return addJSDoc(exportInterface('BlueprintField', [
         addJSDoc(requiredProp('name', t.tsStringKeyword()), 'The column name.'),
-        addJSDoc(requiredProp('type', t.tsStringKeyword()), 'The PostgreSQL type (e.g., "text", "integer", "boolean", "uuid").'),
+        addJSDoc(requiredProp('type', t.tsUnionType([fieldTypeRef, t.tsStringKeyword()])), 'PostgreSQL type as a FieldType object (e.g., { name: "text" }) or legacy string.'),
         addJSDoc(optionalProp('is_required', t.tsBooleanKeyword()), 'Whether the column has a NOT NULL constraint.'),
-        addJSDoc(optionalProp('default_value', t.tsStringKeyword()), 'SQL default value expression (e.g., "true", "now()").'),
+        addJSDoc(optionalProp('default_value', t.tsUnionType([fieldDefaultRef, t.tsStringKeyword()])), 'Default value as a FieldDefault object (e.g., { function: "now" }) or legacy string.'),
         addJSDoc(optionalProp('description', t.tsStringKeyword()), 'Comment/description for this field.')
     ]), 'A custom field (column) to add to a blueprint table.');
 }
@@ -728,6 +780,8 @@ function buildProgram(meta) {
     // -- Shared recursive types (emitted before parameter interfaces) --
     statements.push(sectionComment('Shared recursive types'));
     statements.push(buildTriggerConditionInterface());
+    statements.push(buildFieldTypeInterface());
+    statements.push(buildFieldDefaultInterface());
     // -- Parameter interfaces grouped by category --
     const categoryOrder = ['billing', 'check', 'data', 'event', 'limit', 'limit_enforce', 'limit_track', 'limit_warning', 'search', 'job', 'process', 'authz', 'relation', 'view'];
     for (const cat of categoryOrder) {

package/esm/data/check-greater-than.js

@@ -10,21 +10,21 @@ export const CheckGreaterThan = {
             column: {
                 type: 'string',
                 format: 'column-ref',
-                description: 'Single column to compare against value (mutually exclusive with columns)',
+                description: 'Single column to compare against value (mutually exclusive with columns)'
             },
             value: {
                 type: 'number',
                 description: 'Threshold value for single-column comparison (column > value)',
-                default: 0,
+                default: 0
             },
             columns: {
                 type: 'array',
                 items: { type: 'string', format: 'column-ref' },
                 description: 'Two columns for cross-column comparison (columns[0] > columns[1])',
                 minItems: 2,
-                maxItems: 2,
-            },
-        },
+                maxItems: 2
+            }
+        }
     },
-    tags: ['check', 'constraint', 'validation', 'comparison'],
+    tags: ['check', 'constraint', 'validation', 'comparison']
 };

package/esm/data/check-less-than.js

@@ -10,20 +10,20 @@ export const CheckLessThan = {
             column: {
                 type: 'string',
                 format: 'column-ref',
-                description: 'Single column to compare against value (mutually exclusive with columns)',
+                description: 'Single column to compare against value (mutually exclusive with columns)'
             },
             value: {
                 type: 'number',
-                description: 'Threshold value for single-column comparison (column < value)',
+                description: 'Threshold value for single-column comparison (column < value)'
             },
             columns: {
                 type: 'array',
                 items: { type: 'string', format: 'column-ref' },
                 description: 'Two columns for cross-column comparison (columns[0] < columns[1])',
                 minItems: 2,
-                maxItems: 2,
-            },
-        },
+                maxItems: 2
+            }
+        }
     },
-    tags: ['check', 'constraint', 'validation', 'comparison'],
+    tags: ['check', 'constraint', 'validation', 'comparison']
 };

package/esm/data/check-not-equal.js

@@ -12,10 +12,10 @@ export const CheckNotEqual = {
                 items: { type: 'string', format: 'column-ref' },
                 description: 'Two columns that must not be equal',
                 minItems: 2,
-                maxItems: 2,
-            },
+                maxItems: 2
+            }
         },
-        required: ['columns'],
+        required: ['columns']
     },
-    tags: ['check', 'constraint', 'validation', 'inequality'],
+    tags: ['check', 'constraint', 'validation', 'inequality']
 };

package/esm/data/check-one-of.js

@@ -10,15 +10,15 @@ export const CheckOneOf = {
             column: {
                 type: 'string',
                 format: 'column-ref',
-                description: 'Column to validate against the allowed values',
+                description: 'Column to validate against the allowed values'
             },
             values: {
                 type: 'array',
                 items: { type: 'string' },
-                description: 'Array of allowed values for the column',
-            },
+                description: 'Array of allowed values for the column'
+            }
         },
-        required: ['column', 'values'],
+        required: ['column', 'values']
     },
-    tags: ['check', 'constraint', 'validation', 'enum'],
+    tags: ['check', 'constraint', 'validation', 'enum']
 };

package/esm/data/data-jsonb.js

@@ -14,9 +14,10 @@ export const DataJsonb = {
                 default: 'metadata'
             },
             default_value: {
-                type: 'string',
-                description: 'Default value expression',
-                default: "'{}'::jsonb"
+                type: 'object',
+                description: 'Default value as a FieldDefault object',
+                'x-codegen-type': 'FieldDefault',
+                default: { value: {}, cast: { name: 'jsonb' } }
             },
             is_required: {
                 type: 'boolean',

package/esm/data/data-status-field.js

@@ -14,9 +14,10 @@ export const DataStatusField = {
                 default: 'status'
             },
             type: {
-                type: 'string',
-                description: 'Column type (text or citext)',
-                default: 'text'
+                type: 'object',
+                description: 'Column type as a FieldType object',
+                'x-codegen-type': 'FieldType',
+                default: { name: 'text' }
             },
             default_value: {
                 type: 'string',

package/esm/data/data-tags.js

@@ -14,9 +14,10 @@ export const DataTags = {
                 default: 'tags'
             },
             default_value: {
-                type: 'string',
-                description: 'Default value expression for the tags column',
-                default: 'ARRAY[]::citext[]'
+                type: 'object',
+                description: 'Default value as a FieldDefault object',
+                'x-codegen-type': 'FieldDefault',
+                default: { value: [], cast: { name: 'citext', array_dimensions: 1 } }
             },
             is_required: {
                 type: 'boolean',

package/esm/event/referral.js

@@ -39,7 +39,26 @@ export const EventReferral = {
             entity_field: {
                 type: 'string',
                 format: 'column-ref',
-                description: 'Column containing the entity ID (org/group) for entity-scoped referral events. Omit for user-only events.'
+                description: 'Column containing the entity ID (org/group) for entity-scoped referral events. For FK lookups (e.g., channel_id → channels.entity_id), combine with entity_lookup. Omit for user-only events.'
+            },
+            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']
             },
             max_depth: {
                 type: 'integer',
@@ -49,7 +68,7 @@ export const EventReferral = {
                     'be combined with entity_field.',
                 default: 1,
                 minimum: 1,
-                maximum: 10,
+                maximum: 10
             },
             auto_register_type: {
                 type: 'boolean',

package/esm/event/tracker.js

@@ -49,7 +49,26 @@ export const EventTracker = {
             entity_field: {
                 type: 'string',
                 format: 'column-ref',
-                description: 'Column containing the entity ID (org/group) for entity-scoped events. Omit for user-only events.'
+                description: 'Column containing the entity ID (org/group) for entity-scoped events. For FK lookups (e.g., channel_id → channels.entity_id), combine with entity_lookup. Omit for user-only events.'
+            },
+            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']
             },
             auto_register_type: {
                 type: 'boolean',

package/esm/index.d.ts

@@ -8,7 +8,7 @@ export * from './limit';
 export * from './module-presets';
 export * from './process';
 export * from './relation';
-export type { JSONSchema, NodeTypeDefinition } from './types';
+export type { FieldDefault, FieldDefaultArg, FieldType, JSONSchema, NodeTypeDefinition } from './types';
 export * from './view';
 import type { NodeTypeDefinition } from './types';
 export declare const allNodeTypes: NodeTypeDefinition[];

package/esm/limit/enforce-aggregate.js

@@ -9,25 +9,49 @@ export const LimitEnforceAggregate = {
         properties: {
             limit_name: {
                 type: 'string',
-                description: 'Name of the aggregate limit to track (must match a default_limits entry, e.g. "databases", "members")',
+                description: 'Name of the aggregate limit to track (must match a default_limits 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']
             },
             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', 'aggregates', 'enforce'],
+    tags: ['limits', 'triggers', 'aggregates', 'enforce']
 };

package/esm/limit/enforce-counter.js

@@ -9,31 +9,54 @@ export const 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']
 };