@constructive-io/sdk 0.25.0 → 0.25.1

package/esm/modules/orm/models/userSettingsModule.d.ts

@@ -0,0 +1,54 @@
+/**
+ * UserSettingsModule model for ORM client
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { OrmClient } from '../client';
+import { QueryBuilder } from '../query-builder';
+import type { ConnectionResult, FindManyArgs, FindFirstArgs, CreateArgs, UpdateArgs, DeleteArgs, InferSelectResult, StrictSelect } from '../select-types';
+import type { UserSettingsModuleWithRelations, UserSettingsModuleSelect, UserSettingsModuleFilter, UserSettingsModuleOrderBy, CreateUserSettingsModuleInput, UserSettingsModulePatch } from '../input-types';
+export declare class UserSettingsModuleModel {
+    private client;
+    constructor(client: OrmClient);
+    findMany<S extends UserSettingsModuleSelect>(args: FindManyArgs<S, UserSettingsModuleFilter, UserSettingsModuleOrderBy> & {
+        select: S;
+    } & StrictSelect<S, UserSettingsModuleSelect>): QueryBuilder<{
+        userSettingsModules: ConnectionResult<InferSelectResult<UserSettingsModuleWithRelations, S>>;
+    }>;
+    findFirst<S extends UserSettingsModuleSelect>(args: FindFirstArgs<S, UserSettingsModuleFilter, UserSettingsModuleOrderBy> & {
+        select: S;
+    } & StrictSelect<S, UserSettingsModuleSelect>): QueryBuilder<{
+        userSettingsModule: InferSelectResult<UserSettingsModuleWithRelations, S> | null;
+    }>;
+    findOne<S extends UserSettingsModuleSelect>(args: {
+        id: string;
+        select: S;
+    } & StrictSelect<S, UserSettingsModuleSelect>): QueryBuilder<{
+        userSettingsModule: InferSelectResult<UserSettingsModuleWithRelations, S> | null;
+    }>;
+    create<S extends UserSettingsModuleSelect>(args: CreateArgs<S, CreateUserSettingsModuleInput['userSettingsModule']> & {
+        select: S;
+    } & StrictSelect<S, UserSettingsModuleSelect>): QueryBuilder<{
+        createUserSettingsModule: {
+            userSettingsModule: InferSelectResult<UserSettingsModuleWithRelations, S>;
+        };
+    }>;
+    update<S extends UserSettingsModuleSelect>(args: UpdateArgs<S, {
+        id: string;
+    }, UserSettingsModulePatch> & {
+        select: S;
+    } & StrictSelect<S, UserSettingsModuleSelect>): QueryBuilder<{
+        updateUserSettingsModule: {
+            userSettingsModule: InferSelectResult<UserSettingsModuleWithRelations, S>;
+        };
+    }>;
+    delete<S extends UserSettingsModuleSelect>(args: DeleteArgs<{
+        id: string;
+    }, S> & {
+        select: S;
+    } & StrictSelect<S, UserSettingsModuleSelect>): QueryBuilder<{
+        deleteUserSettingsModule: {
+            userSettingsModule: InferSelectResult<UserSettingsModuleWithRelations, S>;
+        };
+    }>;
+}

package/esm/{public/orm/models/user.js → modules/orm/models/userSettingsModule.js}

@@ -1,12 +1,12 @@
 import { QueryBuilder, buildFindManyDocument, buildFindFirstDocument, buildCreateDocument, buildUpdateByPkDocument, buildDeleteByPkDocument, } from '../query-builder';
 import { connectionFieldsMap } from '../input-types';
-export class UserModel {
+export class UserSettingsModuleModel {
     client;
     constructor(client) {
         this.client = client;
     }
     findMany(args) {
-        const { document, variables } = buildFindManyDocument('User', 'users', args.select, {
+        const { document, variables } = buildFindManyDocument('UserSettingsModule', 'userSettingsModules', args.select, {
             where: args?.where,
             orderBy: args?.orderBy,
             first: args?.first,
@@ -14,85 +14,85 @@ export class UserModel {
             after: args?.after,
             before: args?.before,
             offset: args?.offset,
-        }, 'UserFilter', 'UserOrderBy', connectionFieldsMap);
+        }, 'UserSettingsModuleFilter', 'UserSettingsModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
-            operationName: 'User',
-            fieldName: 'users',
+            operationName: 'UserSettingsModule',
+            fieldName: 'userSettingsModules',
             document,
             variables,
         });
     }
     findFirst(args) {
-        const { document, variables } = buildFindFirstDocument('User', 'users', args.select, {
+        const { document, variables } = buildFindFirstDocument('UserSettingsModule', 'userSettingsModules', args.select, {
             where: args?.where,
             orderBy: args?.orderBy,
-        }, 'UserFilter', 'UserOrderBy', connectionFieldsMap);
+        }, 'UserSettingsModuleFilter', 'UserSettingsModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
-            operationName: 'User',
-            fieldName: 'user',
+            operationName: 'UserSettingsModule',
+            fieldName: 'userSettingsModule',
             document,
             variables,
             transform: (data) => ({
-                user: data.users?.nodes?.[0] ?? null,
+                userSettingsModule: data.userSettingsModules?.nodes?.[0] ?? null,
             }),
         });
     }
     findOne(args) {
-        const { document, variables } = buildFindManyDocument('User', 'users', args.select, {
+        const { document, variables } = buildFindManyDocument('UserSettingsModule', 'userSettingsModules', args.select, {
             where: {
                 id: {
                     equalTo: args.id,
                 },
             },
             first: 1,
-        }, 'UserFilter', 'UserOrderBy', connectionFieldsMap);
+        }, 'UserSettingsModuleFilter', 'UserSettingsModuleOrderBy', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'query',
-            operationName: 'User',
-            fieldName: 'user',
+            operationName: 'UserSettingsModule',
+            fieldName: 'userSettingsModule',
             document,
             variables,
             transform: (data) => ({
-                user: data.users?.nodes?.[0] ?? null,
+                userSettingsModule: data.userSettingsModules?.nodes?.[0] ?? null,
             }),
         });
     }
     create(args) {
-        const { document, variables } = buildCreateDocument('User', 'createUser', 'user', args.select, args.data, 'CreateUserInput', connectionFieldsMap);
+        const { document, variables } = buildCreateDocument('UserSettingsModule', 'createUserSettingsModule', 'userSettingsModule', args.select, args.data, 'CreateUserSettingsModuleInput', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'mutation',
-            operationName: 'User',
-            fieldName: 'createUser',
+            operationName: 'UserSettingsModule',
+            fieldName: 'createUserSettingsModule',
             document,
             variables,
         });
     }
     update(args) {
-        const { document, variables } = buildUpdateByPkDocument('User', 'updateUser', 'user', args.select, args.where.id, args.data, 'UpdateUserInput', 'id', 'userPatch', connectionFieldsMap);
+        const { document, variables } = buildUpdateByPkDocument('UserSettingsModule', 'updateUserSettingsModule', 'userSettingsModule', args.select, args.where.id, args.data, 'UpdateUserSettingsModuleInput', 'id', 'userSettingsModulePatch', connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'mutation',
-            operationName: 'User',
-            fieldName: 'updateUser',
+            operationName: 'UserSettingsModule',
+            fieldName: 'updateUserSettingsModule',
             document,
             variables,
         });
     }
     delete(args) {
-        const { document, variables } = buildDeleteByPkDocument('User', 'deleteUser', 'user', {
+        const { document, variables } = buildDeleteByPkDocument('UserSettingsModule', 'deleteUserSettingsModule', 'userSettingsModule', {
             id: args.where.id,
-        }, 'DeleteUserInput', args.select, connectionFieldsMap);
+        }, 'DeleteUserSettingsModuleInput', args.select, connectionFieldsMap);
         return new QueryBuilder({
             client: this.client,
             operation: 'mutation',
-            operationName: 'User',
-            fieldName: 'deleteUser',
+            operationName: 'UserSettingsModule',
+            fieldName: 'deleteUserSettingsModule',
             document,
             variables,
         });

package/esm/modules/orm/mutation/index.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Custom mutation operations
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { OrmClient } from '../client';
+import { QueryBuilder } from '../query-builder';
+import type { InferSelectResult, StrictSelect } from '../select-types';
+import type { ConstructBlueprintInput, ProvisionFullTextSearchInput, ProvisionIndexInput, ProvisionCheckConstraintInput, ProvisionUniqueConstraintInput, CopyTemplateToBlueprintInput, ProvisionSpatialRelationInput, ProvisionTableInput, ProvisionRelationInput, ProvisionBucketInput, ConstructBlueprintPayload, ProvisionFullTextSearchPayload, ProvisionIndexPayload, ProvisionCheckConstraintPayload, ProvisionUniqueConstraintPayload, CopyTemplateToBlueprintPayload, ProvisionSpatialRelationPayload, ProvisionTablePayload, ProvisionRelationPayload, ProvisionBucketPayload, ConstructBlueprintPayloadSelect, ProvisionFullTextSearchPayloadSelect, ProvisionIndexPayloadSelect, ProvisionCheckConstraintPayloadSelect, ProvisionUniqueConstraintPayloadSelect, CopyTemplateToBlueprintPayloadSelect, ProvisionSpatialRelationPayloadSelect, ProvisionTablePayloadSelect, ProvisionRelationPayloadSelect, ProvisionBucketPayloadSelect } from '../input-types';
+/**
+ * Variables for constructBlueprint
+ * Executes a blueprint definition by delegating to provision_* procedures. Creates a blueprint_construction record to track the attempt. Eight phases: (0) entity_type_provision for each membership_type entry — provisions entity tables, membership modules, and security. When a prefix already exists (e.g., 'org'), the entry extends the existing entity type instead of creating a new one; if a storage[] key is present, it provisions entity-scoped storage for that type. (0.5) scope-based storage: each storage[] entry has an optional scope ('app' or 'org' only). App-scoped storage seeds buckets at migration time. Org-scoped storage resolves the org membership type, creates org_buckets/org_files with owner_id, and seeds buckets per-entity via an AFTER INSERT trigger on the users table. When function_module is installed, a private functions bucket is auto-injected into org-scoped or entity-scoped storage entries. (1) provision_table() for each table with nodes[], fields[], policies[], and grants (table-level indexes/fts/unique_constraints/check_constraints are deferred). After provisioning, optional smart_tags (jsonb object) on the table entry are applied via metaschema.append_table_smart_tags(), and optional smart_tags on individual field entries are applied via metaschema.append_field_smart_tags(). (2) provision_relation() for each relation, (3) provision_index() for top-level + deferred indexes, (4) provision_full_text_search() for top-level + deferred FTS, (5) provision_unique_constraint() for top-level + deferred unique constraints, (6) provision_check_constraint() for top-level + deferred check constraints, (7) seed achievements from definition.achievements[] — resolves events_module by entity_prefix and creates INSERT actions for levels, level_requirements, and achievement_rewards tables. Phase 0 entity tables are added to the table_map so subsequent phases can reference them by name. Table-level entries are deferred to phases 3-6 so they can reference columns created by relations in phase 2. Returns the construction record ID on success, NULL on failure.
+ */
+export interface ConstructBlueprintVariables {
+    input: ConstructBlueprintInput;
+}
+/**
+ * Variables for provisionFullTextSearch
+ * Creates a full-text search configuration on a table. Accepts a jsonb definition with field (tsvector column name) and sources (array of {field, weight, lang}). Graceful: skips if FTS config already exists for the same (table_id, field_id). Returns the fts_id.
+ */
+export interface ProvisionFullTextSearchVariables {
+    input: ProvisionFullTextSearchInput;
+}
+/**
+ * Variables for provisionIndex
+ * Creates an index on a table. Accepts a jsonb definition with columns (array of names or single column string), access_method (default BTREE), is_unique, op_classes, options, and name (auto-generated if omitted). Graceful: skips if an index with the same (table_id, field_ids, access_method) already exists. Returns the index_id.
+ */
+export interface ProvisionIndexVariables {
+    input: ProvisionIndexInput;
+}
+/**
+ * Variables for provisionCheckConstraint
+ * Creates a check constraint on a table from a $type + data blueprint definition. Supports: CheckOneOf (enum validation via = ANY(ARRAY[...])), CheckGreaterThan (single-column > value or cross-column), CheckLessThan (single-column < value or cross-column), CheckNotEqual (cross-column inequality). Builds AST expressions via ast_helpers and inserts into metaschema_public.check_constraint. Graceful: skips if a constraint with the same name already exists.
+ */
+export interface ProvisionCheckConstraintVariables {
+    input: ProvisionCheckConstraintInput;
+}
+/**
+ * Variables for provisionUniqueConstraint
+ * Creates a unique constraint on a table. Accepts a jsonb definition with columns (array of field names). Graceful: skips if the exact same unique constraint already exists.
+ */
+export interface ProvisionUniqueConstraintVariables {
+    input: ProvisionUniqueConstraintInput;
+}
+/**
+ * Variables for copyTemplateToBlueprint
+ * Creates a new blueprint by copying a template definition. Checks visibility: owners can always copy their own templates, others require public visibility. Increments the template copy_count. Returns the new blueprint ID.
+ */
+export interface CopyTemplateToBlueprintVariables {
+    input: CopyTemplateToBlueprintInput;
+}
+/**
+ * Variables for provisionSpatialRelation
+ * Idempotent provisioner for metaschema_public.spatial_relation. Inserts a row declaring a spatial predicate between two geometry/geography columns (owner and target). Called from construct_blueprint when a relation entry has $type=RelationSpatial. Graceful: re-running with the same (source_table_id, name) returns the existing id without modifying the row. Operator whitelist and st_dwithin ↔ param_name pairing are enforced by the spatial_relation table CHECKs. Both fields must already exist — this is a metadata-only insert.
+ */
+export interface ProvisionSpatialRelationVariables {
+    input: ProvisionSpatialRelationInput;
+}
+/**
+ * Variables for provisionTable
+ * Composable table provisioning: creates or finds a table, then creates fields (so Data* modules can reference them), applies N nodes (Data* modules), enables RLS, creates grants, creates N policies, and optionally creates table-level indexes/full_text_searches/unique_constraints. All operations are graceful (skip existing). Accepts multiple nodes and multiple policies per call, unlike secure_table_provision which is limited to one of each. Returns (out_table_id, out_fields).
+ */
+export interface ProvisionTableVariables {
+    input: ProvisionTableInput;
+}
+/**
+ * Variables for provisionRelation
+ * Composable relation provisioning: creates FK fields, indexes, unique constraints, and junction tables depending on the relation_type. Supports RelationBelongsTo, RelationHasOne, RelationHasMany, and RelationManyToMany. ManyToMany uses provision_table() internally for junction table creation with full node/grant/policy support. All operations are graceful (skip existing). Returns (out_field_id, out_junction_table_id, out_source_field_id, out_target_field_id).
+ */
+export interface ProvisionRelationVariables {
+    input: ProvisionRelationInput;
+}
+/**
+ * Variables for provisionBucket
+ * Provision an S3 bucket for a logical bucket in the database.
+Reads the bucket config via RLS, then creates and configures
+the S3 bucket with the appropriate privacy policies, CORS rules,
+and lifecycle settings.
+ */
+export interface ProvisionBucketVariables {
+    input: ProvisionBucketInput;
+}
+export declare function createMutationOperations(client: OrmClient): {
+    constructBlueprint: <S extends ConstructBlueprintPayloadSelect>(args: ConstructBlueprintVariables, options: {
+        select: S;
+    } & StrictSelect<S, ConstructBlueprintPayloadSelect>) => QueryBuilder<{
+        constructBlueprint: InferSelectResult<ConstructBlueprintPayload, S> | null;
+    }>;
+    provisionFullTextSearch: <S extends ProvisionFullTextSearchPayloadSelect>(args: ProvisionFullTextSearchVariables, options: {
+        select: S;
+    } & StrictSelect<S, ProvisionFullTextSearchPayloadSelect>) => QueryBuilder<{
+        provisionFullTextSearch: InferSelectResult<ProvisionFullTextSearchPayload, S> | null;
+    }>;
+    provisionIndex: <S extends ProvisionIndexPayloadSelect>(args: ProvisionIndexVariables, options: {
+        select: S;
+    } & StrictSelect<S, ProvisionIndexPayloadSelect>) => QueryBuilder<{
+        provisionIndex: InferSelectResult<ProvisionIndexPayload, S> | null;
+    }>;
+    provisionCheckConstraint: <S extends ProvisionCheckConstraintPayloadSelect>(args: ProvisionCheckConstraintVariables, options: {
+        select: S;
+    } & StrictSelect<S, ProvisionCheckConstraintPayloadSelect>) => QueryBuilder<{
+        provisionCheckConstraint: InferSelectResult<ProvisionCheckConstraintPayload, S> | null;
+    }>;
+    provisionUniqueConstraint: <S extends ProvisionUniqueConstraintPayloadSelect>(args: ProvisionUniqueConstraintVariables, options: {
+        select: S;
+    } & StrictSelect<S, ProvisionUniqueConstraintPayloadSelect>) => QueryBuilder<{
+        provisionUniqueConstraint: InferSelectResult<ProvisionUniqueConstraintPayload, S> | null;
+    }>;
+    copyTemplateToBlueprint: <S extends CopyTemplateToBlueprintPayloadSelect>(args: CopyTemplateToBlueprintVariables, options: {
+        select: S;
+    } & StrictSelect<S, CopyTemplateToBlueprintPayloadSelect>) => QueryBuilder<{
+        copyTemplateToBlueprint: InferSelectResult<CopyTemplateToBlueprintPayload, S> | null;
+    }>;
+    provisionSpatialRelation: <S extends ProvisionSpatialRelationPayloadSelect>(args: ProvisionSpatialRelationVariables, options: {
+        select: S;
+    } & StrictSelect<S, ProvisionSpatialRelationPayloadSelect>) => QueryBuilder<{
+        provisionSpatialRelation: InferSelectResult<ProvisionSpatialRelationPayload, S> | null;
+    }>;
+    provisionTable: <S extends ProvisionTablePayloadSelect>(args: ProvisionTableVariables, options: {
+        select: S;
+    } & StrictSelect<S, ProvisionTablePayloadSelect>) => QueryBuilder<{
+        provisionTable: InferSelectResult<ProvisionTablePayload, S> | null;
+    }>;
+    provisionRelation: <S extends ProvisionRelationPayloadSelect>(args: ProvisionRelationVariables, options: {
+        select: S;
+    } & StrictSelect<S, ProvisionRelationPayloadSelect>) => QueryBuilder<{
+        provisionRelation: InferSelectResult<ProvisionRelationPayload, S> | null;
+    }>;
+    provisionBucket: <S extends ProvisionBucketPayloadSelect>(args: ProvisionBucketVariables, options: {
+        select: S;
+    } & StrictSelect<S, ProvisionBucketPayloadSelect>) => QueryBuilder<{
+        provisionBucket: InferSelectResult<ProvisionBucketPayload, S> | null;
+    }>;
+};

package/esm/modules/orm/mutation/index.js

@@ -0,0 +1,126 @@
+import { QueryBuilder, buildCustomDocument } from '../query-builder';
+import { connectionFieldsMap } from '../input-types';
+export function createMutationOperations(client) {
+    return {
+        constructBlueprint: (args, options) => new QueryBuilder({
+            client,
+            operation: 'mutation',
+            operationName: 'ConstructBlueprint',
+            fieldName: 'constructBlueprint',
+            ...buildCustomDocument('mutation', 'ConstructBlueprint', 'constructBlueprint', options.select, args, [
+                {
+                    name: 'input',
+                    type: 'ConstructBlueprintInput!',
+                },
+            ], connectionFieldsMap, 'ConstructBlueprintPayload'),
+        }),
+        provisionFullTextSearch: (args, options) => new QueryBuilder({
+            client,
+            operation: 'mutation',
+            operationName: 'ProvisionFullTextSearch',
+            fieldName: 'provisionFullTextSearch',
+            ...buildCustomDocument('mutation', 'ProvisionFullTextSearch', 'provisionFullTextSearch', options.select, args, [
+                {
+                    name: 'input',
+                    type: 'ProvisionFullTextSearchInput!',
+                },
+            ], connectionFieldsMap, 'ProvisionFullTextSearchPayload'),
+        }),
+        provisionIndex: (args, options) => new QueryBuilder({
+            client,
+            operation: 'mutation',
+            operationName: 'ProvisionIndex',
+            fieldName: 'provisionIndex',
+            ...buildCustomDocument('mutation', 'ProvisionIndex', 'provisionIndex', options.select, args, [
+                {
+                    name: 'input',
+                    type: 'ProvisionIndexInput!',
+                },
+            ], connectionFieldsMap, 'ProvisionIndexPayload'),
+        }),
+        provisionCheckConstraint: (args, options) => new QueryBuilder({
+            client,
+            operation: 'mutation',
+            operationName: 'ProvisionCheckConstraint',
+            fieldName: 'provisionCheckConstraint',
+            ...buildCustomDocument('mutation', 'ProvisionCheckConstraint', 'provisionCheckConstraint', options.select, args, [
+                {
+                    name: 'input',
+                    type: 'ProvisionCheckConstraintInput!',
+                },
+            ], connectionFieldsMap, 'ProvisionCheckConstraintPayload'),
+        }),
+        provisionUniqueConstraint: (args, options) => new QueryBuilder({
+            client,
+            operation: 'mutation',
+            operationName: 'ProvisionUniqueConstraint',
+            fieldName: 'provisionUniqueConstraint',
+            ...buildCustomDocument('mutation', 'ProvisionUniqueConstraint', 'provisionUniqueConstraint', options.select, args, [
+                {
+                    name: 'input',
+                    type: 'ProvisionUniqueConstraintInput!',
+                },
+            ], connectionFieldsMap, 'ProvisionUniqueConstraintPayload'),
+        }),
+        copyTemplateToBlueprint: (args, options) => new QueryBuilder({
+            client,
+            operation: 'mutation',
+            operationName: 'CopyTemplateToBlueprint',
+            fieldName: 'copyTemplateToBlueprint',
+            ...buildCustomDocument('mutation', 'CopyTemplateToBlueprint', 'copyTemplateToBlueprint', options.select, args, [
+                {
+                    name: 'input',
+                    type: 'CopyTemplateToBlueprintInput!',
+                },
+            ], connectionFieldsMap, 'CopyTemplateToBlueprintPayload'),
+        }),
+        provisionSpatialRelation: (args, options) => new QueryBuilder({
+            client,
+            operation: 'mutation',
+            operationName: 'ProvisionSpatialRelation',
+            fieldName: 'provisionSpatialRelation',
+            ...buildCustomDocument('mutation', 'ProvisionSpatialRelation', 'provisionSpatialRelation', options.select, args, [
+                {
+                    name: 'input',
+                    type: 'ProvisionSpatialRelationInput!',
+                },
+            ], connectionFieldsMap, 'ProvisionSpatialRelationPayload'),
+        }),
+        provisionTable: (args, options) => new QueryBuilder({
+            client,
+            operation: 'mutation',
+            operationName: 'ProvisionTable',
+            fieldName: 'provisionTable',
+            ...buildCustomDocument('mutation', 'ProvisionTable', 'provisionTable', options.select, args, [
+                {
+                    name: 'input',
+                    type: 'ProvisionTableInput!',
+                },
+            ], connectionFieldsMap, 'ProvisionTablePayload'),
+        }),
+        provisionRelation: (args, options) => new QueryBuilder({
+            client,
+            operation: 'mutation',
+            operationName: 'ProvisionRelation',
+            fieldName: 'provisionRelation',
+            ...buildCustomDocument('mutation', 'ProvisionRelation', 'provisionRelation', options.select, args, [
+                {
+                    name: 'input',
+                    type: 'ProvisionRelationInput!',
+                },
+            ], connectionFieldsMap, 'ProvisionRelationPayload'),
+        }),
+        provisionBucket: (args, options) => new QueryBuilder({
+            client,
+            operation: 'mutation',
+            operationName: 'ProvisionBucket',
+            fieldName: 'provisionBucket',
+            ...buildCustomDocument('mutation', 'ProvisionBucket', 'provisionBucket', options.select, args, [
+                {
+                    name: 'input',
+                    type: 'ProvisionBucketInput!',
+                },
+            ], connectionFieldsMap, 'ProvisionBucketPayload'),
+        }),
+    };
+}

package/esm/modules/orm/query/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Custom query operations
+ * @generated by @constructive-io/graphql-codegen
+ * DO NOT EDIT - changes will be overwritten
+ */
+import { OrmClient } from '../client';
+import { QueryBuilder } from '../query-builder';
+/**
+ * Variables for resolveBlueprintField
+ * Resolves a field_name within a given table_id to a field_id. Throws if no match is found. Used by construct_blueprint to translate user-authored field names (e.g. "location") into field UUIDs for downstream provisioning procedures. table_id must already be resolved (via resolve_blueprint_table) before calling this.
+ */
+export interface ResolveBlueprintFieldVariables {
+    databaseId?: string;
+    tableId?: string;
+    fieldName?: string;
+}
+/**
+ * Variables for resolveBlueprintTable
+ * Resolves a table_name (with optional schema_name) to a table_id. Resolution order: (1) if schema_name provided, exact lookup via metaschema_public.schema.name + metaschema_public.table; (2) check local table_map (tables created in current blueprint); (3) search metaschema_public.table by name across all schemas; (4) if multiple matches, throw ambiguous error asking for schema_name; (5) if no match, throw not-found error.
+ */
+export interface ResolveBlueprintTableVariables {
+    databaseId?: string;
+    tableName?: string;
+    schemaName?: string;
+    tableMap?: unknown;
+    defaultSchemaId?: string;
+}
+export declare function createQueryOperations(client: OrmClient): {
+    resolveBlueprintField: (args: ResolveBlueprintFieldVariables, options?: {
+        select?: Record<string, unknown>;
+    }) => QueryBuilder<{
+        resolveBlueprintField: string | null;
+    }>;
+    resolveBlueprintTable: (args: ResolveBlueprintTableVariables, options?: {
+        select?: Record<string, unknown>;
+    }) => QueryBuilder<{
+        resolveBlueprintTable: string | null;
+    }>;
+};

package/esm/modules/orm/query/index.js

@@ -0,0 +1,54 @@
+import { QueryBuilder, buildCustomDocument } from '../query-builder';
+import { connectionFieldsMap } from '../input-types';
+export function createQueryOperations(client) {
+    return {
+        resolveBlueprintField: (args, options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'ResolveBlueprintField',
+            fieldName: 'resolveBlueprintField',
+            ...buildCustomDocument('query', 'ResolveBlueprintField', 'resolveBlueprintField', options?.select, args, [
+                {
+                    name: 'databaseId',
+                    type: 'UUID',
+                },
+                {
+                    name: 'tableId',
+                    type: 'UUID',
+                },
+                {
+                    name: 'fieldName',
+                    type: 'String',
+                },
+            ], connectionFieldsMap, undefined),
+        }),
+        resolveBlueprintTable: (args, options) => new QueryBuilder({
+            client,
+            operation: 'query',
+            operationName: 'ResolveBlueprintTable',
+            fieldName: 'resolveBlueprintTable',
+            ...buildCustomDocument('query', 'ResolveBlueprintTable', 'resolveBlueprintTable', options?.select, args, [
+                {
+                    name: 'databaseId',
+                    type: 'UUID',
+                },
+                {
+                    name: 'tableName',
+                    type: 'String',
+                },
+                {
+                    name: 'schemaName',
+                    type: 'String',
+                },
+                {
+                    name: 'tableMap',
+                    type: 'JSON',
+                },
+                {
+                    name: 'defaultSchemaId',
+                    type: 'UUID',
+                },
+            ], connectionFieldsMap, undefined),
+        }),
+    };
+}

package/esm/modules/orm/query-builder.d.ts

@@ -0,0 +1,110 @@
+import type { FieldNode } from 'graphql';
+import { OrmClient, QueryResult } from './client';
+export interface QueryBuilderConfig<TResult> {
+    client: OrmClient;
+    operation: 'query' | 'mutation';
+    operationName: string;
+    fieldName: string;
+    document: string;
+    variables?: Record<string, unknown>;
+    transform?: (data: any) => TResult;
+}
+export declare class QueryBuilder<TResult> {
+    private config;
+    constructor(config: QueryBuilderConfig<TResult>);
+    /**
+     * Execute the query and return a discriminated union result
+     * Use result.ok to check success, or .unwrap() to throw on error
+     */
+    execute(): Promise<QueryResult<TResult>>;
+    /**
+     * Execute and unwrap the result, throwing GraphQLRequestError on failure
+     * @throws {GraphQLRequestError} If the query returns errors
+     */
+    unwrap(): Promise<TResult>;
+    /**
+     * Execute and unwrap, returning defaultValue on error instead of throwing
+     */
+    unwrapOr<D>(defaultValue: D): Promise<TResult | D>;
+    /**
+     * Execute and unwrap, calling onError callback on failure
+     */
+    unwrapOrElse<D>(onError: (errors: import('./client').GraphQLError[]) => D): Promise<TResult | D>;
+    toGraphQL(): string;
+    getVariables(): Record<string, unknown> | undefined;
+}
+export declare function buildSelections(select: Record<string, unknown> | undefined, connectionFieldsMap?: Record<string, Record<string, string>>, entityType?: string): FieldNode[];
+export declare function buildFindManyDocument<TSelect, TWhere>(operationName: string, queryField: string, select: TSelect, args: {
+    where?: TWhere;
+    orderBy?: string[];
+    first?: number;
+    last?: number;
+    after?: string;
+    before?: string;
+    offset?: number;
+}, filterTypeName: string, orderByTypeName: string, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildFindFirstDocument<TSelect, TWhere>(operationName: string, queryField: string, select: TSelect, args: {
+    where?: TWhere;
+    orderBy?: string[];
+}, filterTypeName: string, orderByTypeName: string, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildCreateDocument<TSelect, TData>(operationName: string, mutationField: string, entityField: string, select: TSelect, data: TData, inputTypeName: string, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildUpdateDocument<TSelect, TWhere extends {
+    id: string;
+}, TData>(operationName: string, mutationField: string, entityField: string, select: TSelect, where: TWhere, data: TData, inputTypeName: string, patchFieldName: string, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildUpdateByPkDocument<TSelect, TData>(operationName: string, mutationField: string, entityField: string, select: TSelect, id: string | number, data: TData, inputTypeName: string, idFieldName: string, patchFieldName: string, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildFindOneDocument<TSelect>(operationName: string, queryField: string, id: string | number, select: TSelect, idArgName: string, idTypeName: string, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildDeleteDocument<TWhere extends {
+    id: string;
+}, TSelect = undefined>(operationName: string, mutationField: string, entityField: string, where: TWhere, inputTypeName: string, select?: TSelect, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildDeleteByPkDocument<TSelect = undefined>(operationName: string, mutationField: string, entityField: string, keys: Record<string, unknown>, inputTypeName: string, select?: TSelect, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildJunctionRemoveDocument(operationName: string, mutationField: string, keys: Record<string, unknown>, inputTypeName: string): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildCustomDocument<TSelect, TArgs>(operationType: 'query' | 'mutation', operationName: string, fieldName: string, select: TSelect, args: TArgs, variableDefinitions: Array<{
+    name: string;
+    type: string;
+}>, connectionFieldsMap?: Record<string, Record<string, string>>, entityType?: string): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildBulkInsertDocument<TSelect, TData>(operationName: string, mutationField: string, select: TSelect, data: TData[], inputTypeName: string, onConflict?: unknown, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildBulkUpsertDocument<TSelect, TData>(operationName: string, mutationField: string, select: TSelect, data: TData[], inputTypeName: string, onConflict: unknown, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildBulkUpdateDocument<TSelect, TWhere, TData>(operationName: string, mutationField: string, select: TSelect, where: TWhere, data: TData, inputTypeName: string, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+export declare function buildBulkDeleteDocument<TSelect, TWhere>(operationName: string, mutationField: string, select: TSelect, where: TWhere, inputTypeName: string, connectionFieldsMap?: Record<string, Record<string, string>>): {
+    document: string;
+    variables: Record<string, unknown>;
+};