node-type-registry 0.2.0

package/esm/authz/authz-related-member-list.js

@@ -0,0 +1,40 @@
+export const AuthzRelatedMemberList = {
+    name: 'AuthzRelatedMemberList',
+    slug: 'authz_related_member_list',
+    category: 'authz',
+    display_name: 'Related Member List',
+    description: 'Array membership check in a related table.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "owned_schema": {
+                "type": "string",
+                "description": "Schema of the related table"
+            },
+            "owned_table": {
+                "type": "string",
+                "description": "Name of the related table"
+            },
+            "owned_table_key": {
+                "type": "string",
+                "description": "Array column in related table"
+            },
+            "owned_table_ref_key": {
+                "type": "string",
+                "description": "FK column in related table"
+            },
+            "this_object_key": {
+                "type": "string",
+                "description": "PK column in protected table"
+            }
+        },
+        "required": [
+            "owned_schema",
+            "owned_table",
+            "owned_table_key",
+            "owned_table_ref_key",
+            "this_object_key"
+        ]
+    },
+    tags: ['ownership', 'authz'],
+};

package/esm/authz/authz-related-peer-ownership.d.ts

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

package/esm/authz/authz-related-peer-ownership.js

@@ -0,0 +1,72 @@
+export const AuthzRelatedPeerOwnership = {
+    name: 'AuthzRelatedPeerOwnership',
+    slug: 'authz_related_peer_ownership',
+    category: 'authz',
+    display_name: 'Related Peer Ownership',
+    description: 'Peer visibility through shared entity membership via a related table. Like AuthzPeerOwnership but the owning user is resolved through a FK JOIN to a related table. Combines SPRT self-join with object table JOIN.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "entity_field": {
+                "type": "string",
+                "description": "Column name on protected table referencing the related table (e.g., message_id)"
+            },
+            "membership_type": {
+                "type": [
+                    "integer",
+                    "string"
+                ],
+                "description": "Scope: 1=app, 2=org, 3=group (or string name resolved via membership_types_module)"
+            },
+            "obj_table_id": {
+                "type": "string",
+                "format": "uuid",
+                "description": "UUID of the related table (alternative to obj_schema/obj_table)"
+            },
+            "obj_schema": {
+                "type": "string",
+                "description": "Schema of the related table (or use obj_table_id)"
+            },
+            "obj_table": {
+                "type": "string",
+                "description": "Name of the related table (or use obj_table_id)"
+            },
+            "obj_field_id": {
+                "type": "string",
+                "format": "uuid",
+                "description": "UUID of field on related table containing the owner user ID (alternative to obj_field)"
+            },
+            "obj_field": {
+                "type": "string",
+                "description": "Field name on related table containing the owner user ID (e.g., sender_id)"
+            },
+            "obj_ref_field": {
+                "type": "string",
+                "description": "Field on related table to select for matching entity_field (defaults to id)"
+            },
+            "permission": {
+                "type": "string",
+                "description": "Single permission name to check on the current user membership (resolved to bitstring mask)"
+            },
+            "permissions": {
+                "type": "array",
+                "items": {
+                    "type": "string"
+                },
+                "description": "Multiple permission names to check on the current user membership (ORed together into mask)"
+            },
+            "is_admin": {
+                "type": "boolean",
+                "description": "If true, require is_admin flag on current user membership"
+            },
+            "is_owner": {
+                "type": "boolean",
+                "description": "If true, require is_owner flag on current user membership"
+            }
+        },
+        "required": [
+            "entity_field"
+        ]
+    },
+    tags: ['membership', 'peer', 'authz'],
+};

package/esm/authz/authz-temporal.d.ts

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

package/esm/authz/authz-temporal.js

@@ -0,0 +1,43 @@
+export const AuthzTemporal = {
+    name: 'AuthzTemporal',
+    slug: 'authz_temporal',
+    category: 'authz',
+    display_name: 'Temporal Access',
+    description: 'Time-window based access control. Restricts access based on valid_from and/or valid_until timestamps. At least one of valid_from_field or valid_until_field must be provided.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "valid_from_field": {
+                "type": "string",
+                "description": "Column for start time (at least one of valid_from_field or valid_until_field required)"
+            },
+            "valid_until_field": {
+                "type": "string",
+                "description": "Column for end time (at least one of valid_from_field or valid_until_field required)"
+            },
+            "valid_from_inclusive": {
+                "type": "boolean",
+                "description": "Include start boundary",
+                "default": true
+            },
+            "valid_until_inclusive": {
+                "type": "boolean",
+                "description": "Include end boundary",
+                "default": false
+            }
+        },
+        "anyOf": [
+            {
+                "required": [
+                    "valid_from_field"
+                ]
+            },
+            {
+                "required": [
+                    "valid_until_field"
+                ]
+            }
+        ]
+    },
+    tags: ['temporal', 'authz'],
+};

package/esm/authz/index.d.ts

@@ -0,0 +1,15 @@
+export { AuthzDirectOwner } from './authz-direct-owner';
+export { AuthzDirectOwnerAny } from './authz-direct-owner-any';
+export { AuthzMembership } from './authz-membership-check';
+export { AuthzEntityMembership } from './authz-entity-membership';
+export { AuthzRelatedEntityMembership } from './authz-related-entity-membership';
+export { AuthzOrgHierarchy } from './authz-org-hierarchy';
+export { AuthzTemporal } from './authz-temporal';
+export { AuthzPublishable } from './authz-publishable';
+export { AuthzMemberList } from './authz-member-list';
+export { AuthzRelatedMemberList } from './authz-related-member-list';
+export { AuthzAllowAll } from './authz-allow-all';
+export { AuthzDenyAll } from './authz-deny-all';
+export { AuthzComposite } from './authz-composite';
+export { AuthzPeerOwnership } from './authz-peer-ownership';
+export { AuthzRelatedPeerOwnership } from './authz-related-peer-ownership';

package/esm/authz/index.js

@@ -0,0 +1,15 @@
+export { AuthzDirectOwner } from './authz-direct-owner';
+export { AuthzDirectOwnerAny } from './authz-direct-owner-any';
+export { AuthzMembership } from './authz-membership-check';
+export { AuthzEntityMembership } from './authz-entity-membership';
+export { AuthzRelatedEntityMembership } from './authz-related-entity-membership';
+export { AuthzOrgHierarchy } from './authz-org-hierarchy';
+export { AuthzTemporal } from './authz-temporal';
+export { AuthzPublishable } from './authz-publishable';
+export { AuthzMemberList } from './authz-member-list';
+export { AuthzRelatedMemberList } from './authz-related-member-list';
+export { AuthzAllowAll } from './authz-allow-all';
+export { AuthzDenyAll } from './authz-deny-all';
+export { AuthzComposite } from './authz-composite';
+export { AuthzPeerOwnership } from './authz-peer-ownership';
+export { AuthzRelatedPeerOwnership } from './authz-related-peer-ownership';

package/esm/codegen/generate-seed.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Generate SQL seed scripts from TypeScript node type definitions.
+ *
+ * Uses pgsql-deparser to produce individual INSERT statements per node type,
+ * suitable for use as separate pgpm migration files.
+ *
+ * Usage:
+ *   npx ts-node src/codegen/generate-seed.ts [--outdir <dir>] [--single]
+ *
+ *   --outdir <dir>   Directory to write individual SQL files (default: stdout)
+ *   --single         Emit a single combined seed.sql instead of per-node files
+ *
+ * Examples:
+ *   # Print all INSERT statements to stdout
+ *   npx ts-node src/codegen/generate-seed.ts
+ *
+ *   # Generate individual migration files
+ *   npx ts-node src/codegen/generate-seed.ts --outdir ./deploy/seed
+ *
+ *   # Generate a single combined seed file
+ *   npx ts-node src/codegen/generate-seed.ts --single --outdir ./deploy
+ */
+export {};

package/esm/codegen/generate-seed.js

@@ -0,0 +1,153 @@
+/**
+ * Generate SQL seed scripts from TypeScript node type definitions.
+ *
+ * Uses pgsql-deparser to produce individual INSERT statements per node type,
+ * suitable for use as separate pgpm migration files.
+ *
+ * Usage:
+ *   npx ts-node src/codegen/generate-seed.ts [--outdir <dir>] [--single]
+ *
+ *   --outdir <dir>   Directory to write individual SQL files (default: stdout)
+ *   --single         Emit a single combined seed.sql instead of per-node files
+ *
+ * Examples:
+ *   # Print all INSERT statements to stdout
+ *   npx ts-node src/codegen/generate-seed.ts
+ *
+ *   # Generate individual migration files
+ *   npx ts-node src/codegen/generate-seed.ts --outdir ./deploy/seed
+ *
+ *   # Generate a single combined seed file
+ *   npx ts-node src/codegen/generate-seed.ts --single --outdir ./deploy
+ */
+import { writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { deparse } from 'pgsql-deparser';
+import { ast, nodes } from '@pgsql/utils';
+import { allNodeTypes } from '../index';
+// ---------------------------------------------------------------------------
+// AST helpers
+// ---------------------------------------------------------------------------
+const astr = (val) => nodes.aConst({ sval: ast.string({ sval: val }) });
+const makeCast = (arg, typeName) => ({
+    TypeCast: {
+        arg,
+        typeName: {
+            names: [{ String: { sval: typeName } }],
+            typemod: -1,
+        },
+    },
+});
+const makeArrayExpr = (elements) => ({
+    A_ArrayExpr: { elements },
+});
+// ---------------------------------------------------------------------------
+// Build a single INSERT statement for one node type
+// ---------------------------------------------------------------------------
+function buildInsertStmt(nt) {
+    const cols = [
+        'name',
+        'slug',
+        'category',
+        'display_name',
+        'description',
+        'parameter_schema',
+        'tags',
+    ];
+    const vals = [
+        astr(nt.name),
+        astr(nt.slug),
+        astr(nt.category),
+        astr(nt.display_name),
+        astr(nt.description),
+        makeCast(astr(JSON.stringify(nt.parameter_schema)), 'jsonb'),
+        makeArrayExpr(nt.tags.map((t) => astr(t))),
+    ];
+    return {
+        RawStmt: {
+            stmt: {
+                InsertStmt: {
+                    relation: {
+                        schemaname: 'metaschema_public',
+                        relname: 'node_type_registry',
+                        inh: true,
+                        relpersistence: 'p',
+                    },
+                    cols: cols.map((name) => nodes.resTarget({ name })),
+                    selectStmt: {
+                        SelectStmt: {
+                            valuesLists: [
+                                {
+                                    List: { items: vals },
+                                },
+                            ],
+                            op: 'SETOP_NONE',
+                            limitOption: 'LIMIT_OPTION_DEFAULT',
+                        },
+                    },
+                    onConflictClause: {
+                        action: 'ONCONFLICT_NOTHING',
+                        infer: {
+                            indexElems: [
+                                {
+                                    IndexElem: {
+                                        name: 'slug',
+                                        ordering: 'SORTBY_DEFAULT',
+                                        nulls_ordering: 'SORTBY_NULLS_DEFAULT',
+                                    },
+                                },
+                            ],
+                        },
+                    },
+                    override: 'OVERRIDING_NOT_SET',
+                },
+            },
+            stmt_len: 1,
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// CLI
+// ---------------------------------------------------------------------------
+function main() {
+    const args = process.argv.slice(2);
+    const outdirIdx = args.indexOf('--outdir');
+    const outdir = outdirIdx !== -1 ? args[outdirIdx + 1] : undefined;
+    const single = args.includes('--single');
+    if (single) {
+        // Emit all INSERT statements as a single SQL string
+        const stmts = allNodeTypes.map(buildInsertStmt);
+        const sql = deparse(stmts);
+        if (outdir) {
+            if (!existsSync(outdir))
+                mkdirSync(outdir, { recursive: true });
+            writeFileSync(join(outdir, 'seed.sql'), sql + '\n');
+            console.log(`Wrote ${allNodeTypes.length} node types to ${join(outdir, 'seed.sql')}`);
+        }
+        else {
+            process.stdout.write(sql + '\n');
+        }
+        return;
+    }
+    // Emit individual SQL files per node type
+    const stmts = allNodeTypes.map((nt) => ({
+        nt,
+        sql: deparse([buildInsertStmt(nt)]),
+    }));
+    if (outdir) {
+        if (!existsSync(outdir))
+            mkdirSync(outdir, { recursive: true });
+        for (const { nt, sql } of stmts) {
+            const filename = `${nt.slug}.sql`;
+            writeFileSync(join(outdir, filename), sql + '\n');
+        }
+        console.log(`Wrote ${stmts.length} individual migration files to ${outdir}/`);
+    }
+    else {
+        for (const { nt, sql } of stmts) {
+            console.log(`-- ${nt.name} (${nt.slug})`);
+            console.log(sql + ';\n');
+        }
+    }
+}
+main();

package/esm/data/data-bm25.d.ts

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

package/esm/data/data-bm25.js

@@ -0,0 +1,40 @@
+export const DataBm25 = {
+    name: 'DataBm25',
+    slug: 'data_bm25',
+    category: 'data',
+    display_name: 'BM25 Search',
+    description: '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.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "field_name": {
+                "type": "string",
+                "description": "Name of existing text column to index with BM25"
+            },
+            "text_config": {
+                "type": "string",
+                "description": "PostgreSQL text search configuration for BM25",
+                "default": "english"
+            },
+            "k1": {
+                "type": "number",
+                "description": "BM25 k1 parameter: term frequency saturation (typical: 1.2-2.0)",
+                "default": null
+            },
+            "b": {
+                "type": "number",
+                "description": "BM25 b parameter: document length normalization (0=none, 1=full, typical: 0.75)",
+                "default": null
+            },
+            "search_score_weight": {
+                "type": "number",
+                "description": "Weight for this algorithm in composite searchScore",
+                "default": 1
+            }
+        },
+        "required": [
+            "field_name"
+        ]
+    },
+    tags: ['search', 'bm25', 'schema'],
+};

package/esm/data/data-direct-owner.d.ts

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

package/esm/data/data-direct-owner.js

@@ -0,0 +1,28 @@
+export const DataDirectOwner = {
+    name: 'DataDirectOwner',
+    slug: 'data_direct_owner',
+    category: 'data',
+    display_name: 'Ownership',
+    description: 'Adds ownership column for direct user ownership. Enables AuthzDirectOwner authorization.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "owner_field_name": {
+                "type": "string",
+                "description": "Column name for owner ID",
+                "default": "owner_id"
+            },
+            "include_id": {
+                "type": "boolean",
+                "description": "If true, also adds a UUID primary key column with auto-generation",
+                "default": true
+            },
+            "include_user_fk": {
+                "type": "boolean",
+                "description": "If true, adds a foreign key constraint from owner_id to the users table",
+                "default": true
+            }
+        }
+    },
+    tags: ['ownership', 'schema'],
+};

package/esm/data/data-embedding.d.ts

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

package/esm/data/data-embedding.js

@@ -0,0 +1,79 @@
+export const DataEmbedding = {
+    name: 'DataEmbedding',
+    slug: 'data_embedding',
+    category: 'data',
+    display_name: 'Embedding',
+    description: 'Adds a vector embedding column with HNSW or IVFFlat index for similarity search. Supports configurable dimensions, distance metrics (cosine, l2, ip), stale tracking strategies (column, null, hash), and automatic job enqueue triggers for embedding generation.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "field_name": {
+                "type": "string",
+                "description": "Name of the vector column",
+                "default": "embedding"
+            },
+            "dimensions": {
+                "type": "integer",
+                "description": "Vector dimensions (e.g. 384, 768, 1536, 3072)",
+                "default": 768
+            },
+            "index_method": {
+                "type": "string",
+                "enum": [
+                    "hnsw",
+                    "ivfflat"
+                ],
+                "description": "Index type for similarity search",
+                "default": "hnsw"
+            },
+            "metric": {
+                "type": "string",
+                "enum": [
+                    "cosine",
+                    "l2",
+                    "ip"
+                ],
+                "description": "Distance metric (cosine, l2, ip)",
+                "default": "cosine"
+            },
+            "index_options": {
+                "type": "object",
+                "description": "Index-specific options. HNSW: {m, ef_construction}. IVFFlat: {lists}.",
+                "default": {}
+            },
+            "include_stale_field": {
+                "type": "boolean",
+                "description": "When stale_strategy is column, adds an embedding_stale boolean field",
+                "default": true
+            },
+            "source_fields": {
+                "type": "array",
+                "items": {
+                    "type": "string"
+                },
+                "description": "Column names that feed the embedding. Used by stale trigger to detect content changes."
+            },
+            "enqueue_job": {
+                "type": "boolean",
+                "description": "Auto-create trigger that enqueues embedding generation jobs",
+                "default": true
+            },
+            "job_task_name": {
+                "type": "string",
+                "description": "Task identifier for the job queue",
+                "default": "generate_embedding"
+            },
+            "stale_strategy": {
+                "type": "string",
+                "enum": [
+                    "column",
+                    "null",
+                    "hash"
+                ],
+                "description": "Strategy for tracking embedding staleness. column: embedding_stale boolean. null: set embedding to NULL. hash: md5 hash of source fields.",
+                "default": "column"
+            }
+        }
+    },
+    tags: ['embedding', 'vector', 'ai', 'schema'],
+};

package/esm/data/data-entity-membership.d.ts

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

package/esm/data/data-entity-membership.js

@@ -0,0 +1,28 @@
+export const DataEntityMembership = {
+    name: 'DataEntityMembership',
+    slug: 'data_entity_membership',
+    category: 'data',
+    display_name: 'Entity Membership',
+    description: 'Adds entity reference for organization/group scoping. Enables AuthzEntityMembership, AuthzMembership, AuthzOrgHierarchy authorization.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "entity_field_name": {
+                "type": "string",
+                "description": "Column name for entity ID",
+                "default": "entity_id"
+            },
+            "include_id": {
+                "type": "boolean",
+                "description": "If true, also adds a UUID primary key column with auto-generation",
+                "default": true
+            },
+            "include_user_fk": {
+                "type": "boolean",
+                "description": "If true, adds a foreign key constraint from entity_id to the users table",
+                "default": true
+            }
+        }
+    },
+    tags: ['membership', 'schema'],
+};

package/esm/data/data-full-text-search.d.ts

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

package/esm/data/data-full-text-search.js

@@ -0,0 +1,58 @@
+export const DataFullTextSearch = {
+    name: 'DataFullTextSearch',
+    slug: 'data_full_text_search',
+    category: 'data',
+    display_name: 'Full-Text Search',
+    description: 'Adds a tsvector column with GIN index and automatic trigger population from source fields. Enables PostgreSQL full-text search with configurable weights and language support. Leverages the existing metaschema full_text_search infrastructure.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "field_name": {
+                "type": "string",
+                "description": "Name of the tsvector column",
+                "default": "search"
+            },
+            "source_fields": {
+                "type": "array",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "field": {
+                            "type": "string",
+                            "description": "Name of the source column"
+                        },
+                        "weight": {
+                            "type": "string",
+                            "enum": [
+                                "A",
+                                "B",
+                                "C",
+                                "D"
+                            ],
+                            "description": "tsvector weight class (A=highest, D=lowest)",
+                            "default": "D"
+                        },
+                        "lang": {
+                            "type": "string",
+                            "description": "PostgreSQL text search configuration",
+                            "default": "english"
+                        }
+                    },
+                    "required": [
+                        "field"
+                    ]
+                },
+                "description": "Source columns that feed the tsvector. Each has a field name, weight (A-D), and language config."
+            },
+            "search_score_weight": {
+                "type": "number",
+                "description": "Weight for this algorithm in composite searchScore",
+                "default": 1
+            }
+        },
+        "required": [
+            "source_fields"
+        ]
+    },
+    tags: ['search', 'fts', 'tsvector', 'schema'],
+};

package/esm/data/data-id.d.ts

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

package/esm/data/data-id.js

@@ -0,0 +1,18 @@
+export const DataId = {
+    name: 'DataId',
+    slug: 'data_id',
+    category: 'data',
+    display_name: 'Primary Key ID',
+    description: 'Adds a UUID primary key column with auto-generation default (uuidv7). This is the standard primary key pattern for all tables.',
+    parameter_schema: {
+        "type": "object",
+        "properties": {
+            "field_name": {
+                "type": "string",
+                "description": "Column name for the primary key",
+                "default": "id"
+            }
+        }
+    },
+    tags: ['primary_key', 'schema'],
+};

package/esm/data/data-job-trigger.d.ts

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