@constructive-io/seeder 0.5.0 → 0.5.2

package/dist/index.cjs

@@ -7,7 +7,14 @@ var graphqlRequest = require('graphql-request');
 var crypto = require('crypto');
 var index_js = require('inquirerer/cli/index.js');
 var faker = require('@faker-js/faker');
-var data = require('@constructive-io/data');
+require('@constructive-io/graphql-query/client/index.js');
+var index_js$1 = require('@constructive-io/graphql-query/generators/index.js');
+require('@constructive-io/graphql-query/query-builder.js');
+require('@constructive-io/graphql-query/types/core.js');
+require('@constructive-io/graphql-query/ast.js');
+require('@constructive-io/graphql-query/custom-ast.js');
+require('@constructive-io/graphql-query/meta-object/convert.js');
+require('@constructive-io/graphql-query/meta-object/validate.js');
 var promises = require('fs/promises');
 var path = require('path');
 var url = require('url');
@@ -18023,7 +18030,7 @@ function getBlueprintNames() {
 
 // package.json
 var package_default = {
-  version: "0.5.0"};
+  version: "0.5.2"};
 
 // src/templates/blog/generators.ts
 var POST_STATUSES = ["draft", "published", "archived"];
@@ -20305,20 +20312,680 @@ async function provisionDatabase(db, options) {
 function buildProvisionedEndpoint(domain, subdomain, apiPrefix = "public", port = 3e3) {
   return `http://${apiPrefix}-${subdomain}.${domain}:${port}/graphql`;
 }
+function pgFieldToCamelCase(str) {
+  return str.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+function convertInflection(inflection) {
+  if (!inflection) return void 0;
+  return {
+    allRows: inflection.allRows ?? "",
+    allRowsSimple: inflection.allRowsSimple ?? "",
+    conditionType: inflection.conditionType ?? "",
+    connection: inflection.connection ?? "",
+    createField: inflection.createField ?? "",
+    createInputType: inflection.createInputType ?? "",
+    createPayloadType: inflection.createPayloadType ?? "",
+    deleteByPrimaryKey: inflection.deleteByPrimaryKey ?? null,
+    deletePayloadType: inflection.deletePayloadType ?? "",
+    edge: inflection.edge ?? "",
+    edgeField: inflection.edgeField ?? "",
+    enumType: inflection.enumType ?? "",
+    filterType: inflection.filterType ?? null,
+    inputType: inflection.inputType ?? "",
+    orderByType: inflection.orderByType ?? "",
+    patchField: inflection.patchField ?? "",
+    patchType: inflection.patchType ?? null,
+    tableFieldName: inflection.tableFieldName ?? "",
+    tableType: inflection.tableType ?? "",
+    typeName: inflection.typeName ?? "",
+    updateByPrimaryKey: inflection.updateByPrimaryKey ?? null,
+    updatePayloadType: inflection.updatePayloadType ?? null
+  };
+}
+function convertQueryNames(query) {
+  if (!query) return void 0;
+  return {
+    all: query.all,
+    one: query.one ?? null,
+    create: query.create ?? "",
+    update: query.update ?? null,
+    delete: query.delete ?? null
+  };
+}
+function cleanTable(metaTable) {
+  const relations = metaTable.relations;
+  return {
+    name: metaTable.name,
+    inflection: convertInflection(metaTable.inflection),
+    query: convertQueryNames(metaTable.query),
+    fields: (metaTable.fields || []).filter((f) => f != null).map((field2) => ({
+      name: pgFieldToCamelCase(field2.name),
+      type: {
+        gqlType: field2.type.gqlType,
+        isArray: field2.type.isArray,
+        modifier: field2.type.modifier,
+        pgAlias: field2.type.pgAlias,
+        pgType: field2.type.pgType,
+        subtype: field2.type.subtype,
+        typmod: field2.type.typmod
+      },
+      isNotNull: field2.isNotNull ?? field2.type.isNotNull ?? null,
+      hasDefault: field2.hasDefault ?? field2.type.hasDefault ?? null
+    })),
+    relations: {
+      belongsTo: (relations?.belongsTo || []).filter((r) => r != null).map((relation) => ({
+        fieldName: relation.fieldName ?? null,
+        isUnique: relation.isUnique,
+        referencesTable: relation.references?.name || "",
+        type: relation.type ?? null,
+        keys: (relation.keys || []).filter((k) => k != null).map((key) => ({
+          name: pgFieldToCamelCase(key.name),
+          type: {
+            gqlType: key.type?.gqlType || "",
+            isArray: key.type?.isArray || false,
+            modifier: key.type?.modifier,
+            pgAlias: key.type?.pgAlias,
+            pgType: key.type?.pgType,
+            subtype: key.type?.subtype,
+            typmod: key.type?.typmod
+          }
+        }))
+      })),
+      hasOne: (relations?.hasOne || []).filter((r) => r != null).map((relation) => ({
+        fieldName: relation.fieldName ?? null,
+        isUnique: relation.isUnique,
+        referencedByTable: relation.referencedBy?.name || "",
+        type: relation.type ?? null,
+        keys: (relation.keys || []).filter((k) => k != null).map((key) => ({
+          name: pgFieldToCamelCase(key.name),
+          type: {
+            gqlType: key.type?.gqlType || "",
+            isArray: key.type?.isArray || false,
+            modifier: key.type?.modifier,
+            pgAlias: key.type?.pgAlias,
+            pgType: key.type?.pgType,
+            subtype: key.type?.subtype,
+            typmod: key.type?.typmod
+          }
+        }))
+      })),
+      hasMany: (relations?.hasMany || []).filter((r) => r != null).map((relation) => ({
+        fieldName: relation.fieldName ?? null,
+        isUnique: relation.isUnique,
+        referencedByTable: relation.referencedBy?.name || "",
+        type: relation.type ?? null,
+        keys: (relation.keys || []).filter((k) => k != null).map((key) => ({
+          name: pgFieldToCamelCase(key.name),
+          type: {
+            gqlType: key.type?.gqlType || "",
+            isArray: key.type?.isArray || false,
+            modifier: key.type?.modifier,
+            pgAlias: key.type?.pgAlias,
+            pgType: key.type?.pgType,
+            subtype: key.type?.subtype,
+            typmod: key.type?.typmod
+          }
+        }))
+      })),
+      manyToMany: (relations?.manyToMany || []).filter((r) => r != null).map((relation) => ({
+        fieldName: relation.fieldName ?? null,
+        rightTable: relation.rightTable?.name || "",
+        junctionTable: relation.junctionTable?.name || "",
+        type: relation.type ?? null
+      }))
+    }
+  };
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.prototype.toString.call(value) === "[object Object]";
+}
+function hasNestedDirtyFields(dirtyFields, prefix) {
+  for (const field2 of dirtyFields) {
+    if (field2 === prefix || field2.startsWith(`${prefix}.`)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isFieldOrAncestorDirty(dirtyFields, path2) {
+  if (dirtyFields.has(path2)) return true;
+  const parts = path2.split(".");
+  for (let i = 1; i < parts.length; i++) {
+    const ancestorPath = parts.slice(0, i).join(".");
+    if (dirtyFields.has(ancestorPath)) return true;
+  }
+  return false;
+}
+function getNestedValue(obj, path2) {
+  const parts = path2.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0) return void 0;
+    if (typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function prepareMutationInput(input, options) {
+  const { operation, dirtyFields, defaultValues, alwaysInclude = [], exclude = [], _pathPrefix = "" } = options;
+  const result = {};
+  const alwaysIncludeSet = new Set(alwaysInclude);
+  const excludeSet = new Set(exclude);
+  for (const [key, value] of Object.entries(input)) {
+    const fullPath = _pathPrefix ? `${_pathPrefix}.${key}` : key;
+    const isDirty = dirtyFields ? isFieldOrAncestorDirty(dirtyFields, fullPath) : true;
+    const hasDirtyTracking = !!dirtyFields;
+    if (excludeSet.has(key) || excludeSet.has(fullPath)) continue;
+    if (alwaysIncludeSet.has(key) || alwaysIncludeSet.has(fullPath)) {
+      result[key] = value;
+      continue;
+    }
+    if (value === void 0) continue;
+    if (value === null) {
+      if (operation === "create") {
+        if (hasDirtyTracking && isDirty) {
+          result[key] = null;
+        }
+      } else {
+        if (isDirty) {
+          result[key] = null;
+        }
+      }
+      continue;
+    }
+    if (value === "") {
+      if (operation === "create") {
+        if (hasDirtyTracking && isDirty) {
+          result[key] = "";
+        }
+      } else {
+        if (isDirty) {
+          result[key] = "";
+        }
+      }
+      continue;
+    }
+    if (Array.isArray(value)) {
+      if (hasDirtyTracking && !isDirty && !hasNestedDirtyFields(dirtyFields, fullPath)) {
+        continue;
+      }
+      result[key] = value;
+      continue;
+    }
+    if (isPlainObject(value)) {
+      const hasRelevantDirtyFields = !hasDirtyTracking || isDirty || hasNestedDirtyFields(dirtyFields, fullPath);
+      if (!hasRelevantDirtyFields) {
+        continue;
+      }
+      const nestedResult = prepareMutationInput(value, {
+        ...options,
+        _pathPrefix: fullPath
+      });
+      if (Object.keys(nestedResult).length > 0) {
+        result[key] = nestedResult;
+      }
+      continue;
+    }
+    if (hasDirtyTracking && !isDirty) {
+      continue;
+    }
+    if (defaultValues) {
+      const defaultValue = getNestedValue(defaultValues, fullPath);
+      if (value === defaultValue && !isDirty) {
+        continue;
+      }
+    }
+    result[key] = value;
+  }
+  return result;
+}
+function prepareCreateInput(input, options) {
+  return prepareMutationInput(input, { ...options, operation: "create" });
+}
+var MEMBERSHIP_TYPES = {
+  APP: 1,
+  ORGANIZATION: 2};
+var CRUD_OPERATIONS = ["create", "read", "update", "delete"];
+var CRUD_TO_PRIVILEGE = {
+  create: "INSERT",
+  read: "SELECT",
+  update: "UPDATE",
+  delete: "DELETE"
+};
+var DEFAULT_CRUD_GRANT_PRIVILEGES = [
+  ["select", "*"],
+  ["insert", "*"],
+  ["update", "*"],
+  ["delete", "*"]
+];
+var POLICY_PROVISIONING_CONFIG = {
+  AuthzDirectOwner: {
+    category: "has-module",
+    hasDataNode: true,
+    dataNodeType: "DataDirectOwner",
+    fieldOverrides: {
+      entity_field: {
+        type: "string",
+        required: true,
+        label: "Owner Field Name",
+        placeholder: "owner_id",
+        description: "Column that stores the owner user ID",
+        defaultValue: "owner_id"
+      }
+    }
+  },
+  AuthzEntityMembership: {
+    category: "has-module",
+    hasDataNode: true,
+    dataNodeType: "DataEntityMembership",
+    fieldOverrides: {
+      entity_field: {
+        type: "string",
+        required: true,
+        label: "Entity Field Name",
+        placeholder: "entity_id",
+        description: "Column referencing the org/group",
+        defaultValue: "entity_id"
+      },
+      membership_type: {
+        type: "integer",
+        hidden: true,
+        defaultValue: MEMBERSHIP_TYPES.ORGANIZATION
+      },
+      permission: {
+        type: "string",
+        component: "permission-select",
+        label: "Required Permission",
+        description: "Optional permission the user must have"
+      },
+      is_admin: {
+        type: "boolean",
+        label: "Admins",
+        description: "People with admin access can view this."
+      },
+      is_owner: {
+        type: "boolean",
+        label: "Owners",
+        description: "People who own the membership can view this."
+      }
+    }
+  },
+  AuthzDirectOwnerAny: {
+    category: "needs-fields",
+    hasDataNode: false,
+    fieldOverrides: {
+      entity_fields: {
+        type: "uuid[]",
+        required: true,
+        label: "Owner Fields",
+        description: "UUID columns to check for ownership (OR logic)",
+        defaultValue: ["owner_id"],
+        pgType: "uuid"
+      }
+    }
+  },
+  AuthzMembership: {
+    category: "no-fields",
+    hasDataNode: false,
+    fieldOverrides: {
+      membership_type: {
+        type: "integer",
+        required: true,
+        component: "membership-type-select",
+        label: "Membership Scope",
+        description: "Which type of membership to check against",
+        defaultValue: MEMBERSHIP_TYPES.APP
+      },
+      permission: {
+        type: "string",
+        component: "permission-select",
+        label: "Required Permission",
+        description: "Optional permission the user must have"
+      },
+      is_admin: {
+        type: "boolean",
+        label: "Admins",
+        description: "People with admin access can view this."
+      },
+      is_owner: {
+        type: "boolean",
+        label: "Owners",
+        description: "People who own the membership can view this."
+      }
+    }
+  },
+  AuthzPublishable: {
+    category: "has-module",
+    hasDataNode: true,
+    dataNodeType: "DataPublishable",
+    fieldOverrides: {
+      is_published_field: {
+        type: "string",
+        label: "Published Flag Field",
+        placeholder: "is_published",
+        defaultValue: "is_published"
+      },
+      published_at_field: {
+        type: "string",
+        label: "Published At Field",
+        placeholder: "published_at",
+        defaultValue: "published_at"
+      },
+      require_published_at: {
+        type: "boolean",
+        label: "Require Published At",
+        description: "Also require that the publish date has passed",
+        defaultValue: true
+      }
+    }
+  },
+  AuthzTemporal: {
+    category: "needs-fields",
+    hasDataNode: false,
+    fieldOverrides: {
+      valid_from_field: {
+        type: "string",
+        required: true,
+        label: "Valid From Field",
+        placeholder: "valid_from",
+        description: "Column for start time",
+        defaultValue: "valid_from",
+        pgType: "timestamptz"
+      },
+      valid_until_field: {
+        type: "string",
+        required: true,
+        label: "Valid Until Field",
+        placeholder: "valid_until",
+        description: "Column for end time",
+        defaultValue: "valid_until",
+        pgType: "timestamptz"
+      },
+      valid_from_inclusive: {
+        type: "boolean",
+        label: "Include Start",
+        description: "Include start boundary",
+        defaultValue: true
+      },
+      valid_until_inclusive: {
+        type: "boolean",
+        label: "Include End",
+        description: "Include end boundary",
+        defaultValue: false
+      }
+    }
+  },
+  AuthzMemberList: {
+    category: "needs-fields",
+    hasDataNode: false,
+    fieldOverrides: {
+      array_field: {
+        type: "string",
+        required: true,
+        label: "Member List Field",
+        placeholder: "allowed_users",
+        description: "Column containing list of user IDs",
+        defaultValue: "allowed_users",
+        pgType: "uuid[]"
+      }
+    }
+  },
+  AuthzRelatedMemberList: {
+    category: "needs-table",
+    hasDataNode: false,
+    fieldOverrides: {
+      owned_schema: {
+        hidden: true
+      },
+      owned_table: {
+        type: "string",
+        required: true,
+        component: "table-select",
+        label: "Related Table",
+        placeholder: "groups",
+        description: "Table containing the member list"
+      },
+      owned_table_key: {
+        type: "uuid",
+        required: true,
+        label: "Member List Column",
+        placeholder: "member_ids",
+        description: "List column in related table",
+        dependsOn: "owned_table"
+      },
+      owned_table_ref_key: {
+        type: "uuid",
+        required: true,
+        label: "Reference Key",
+        placeholder: "id",
+        description: "FK column in related table",
+        dependsOn: "owned_table"
+      },
+      this_object_key: {
+        type: "uuid",
+        required: true,
+        label: "Foreign Key",
+        placeholder: "group_id",
+        description: "FK on this table to related table"
+      }
+    }
+  },
+  AuthzRelatedEntityMembership: {
+    category: "needs-table",
+    hasDataNode: false,
+    fieldOverrides: {
+      entity_field: {
+        type: "uuid",
+        required: true,
+        label: "Foreign Key Field",
+        description: "Field on this table referencing the linked table"
+      },
+      membership_type: {
+        type: "integer",
+        required: true,
+        component: "membership-type-select",
+        label: "Membership Scope"
+      },
+      obj_schema: {
+        hidden: true
+      },
+      obj_table: {
+        type: "string",
+        required: true,
+        component: "table-select",
+        label: "Linked Table",
+        description: "Table to check for membership"
+      },
+      obj_field: {
+        type: "uuid",
+        required: true,
+        label: "Entity Field on Linked Table",
+        description: "Field containing entity ID for membership check",
+        dependsOn: "obj_table"
+      },
+      permission: {
+        type: "string",
+        component: "permission-select",
+        label: "Required Permission"
+      },
+      is_admin: {
+        type: "boolean",
+        label: "Admins",
+        description: "People with admin access can view this."
+      },
+      is_owner: {
+        type: "boolean",
+        label: "Owners",
+        description: "People who own the membership can view this."
+      }
+    }
+  },
+  AuthzOrgHierarchy: {
+    category: "has-module",
+    hasDataNode: true,
+    dataNodeType: "DataOwnershipInEntity",
+    disabled: true,
+    fieldOverrides: {
+      direction: {
+        type: "string",
+        required: true,
+        label: "Direction",
+        description: "Which direction to traverse the org hierarchy",
+        defaultValue: "down",
+        options: [
+          { value: "down", label: "Down", description: "Managers can see their subordinates" },
+          { value: "up", label: "Up", description: "Subordinates can see their managers" }
+        ]
+      },
+      entity_field: {
+        type: "string",
+        label: "Entity Field Name",
+        placeholder: "entity_id",
+        description: "Field referencing the org entity",
+        defaultValue: "entity_id"
+      },
+      anchor_field: {
+        type: "string",
+        required: true,
+        label: "Anchor Field",
+        placeholder: "owner_id",
+        description: "Field referencing the user (e.g., owner_id)"
+      },
+      max_depth: {
+        type: "integer",
+        label: "Max Depth",
+        description: "Optional max depth to limit visibility"
+      }
+    }
+  },
+  AuthzAllowAll: {
+    category: "no-fields",
+    hasDataNode: false
+  },
+  AuthzDenyAll: {
+    category: "no-fields",
+    hasDataNode: false
+  },
+  AuthzComposite: {
+    category: "no-fields",
+    hasDataNode: false
+  }
+};
+var AUTO_INJECT_SCHEMA_FIELDS = /* @__PURE__ */ new Set(["owned_schema", "obj_schema"]);
+function getPolicyCategory(policyType) {
+  return POLICY_PROVISIONING_CONFIG[policyType]?.category ?? "no-fields";
+}
+function getDataNodeForPolicy(policyType) {
+  return POLICY_PROVISIONING_CONFIG[policyType]?.dataNodeType;
+}
+function getPolicyFieldDefaults(policyType) {
+  const config = POLICY_PROVISIONING_CONFIG[policyType];
+  if (!config?.fieldOverrides) {
+    return {};
+  }
+  const defaults = {};
+  for (const [key, override] of Object.entries(config.fieldOverrides)) {
+    if (override.defaultValue !== void 0) {
+      defaults[key] = override.defaultValue;
+    }
+  }
+  return defaults;
+}
+function getFieldsRequiringColumns(policyType) {
+  const config = POLICY_PROVISIONING_CONFIG[policyType];
+  if (!config?.fieldOverrides) {
+    return [];
+  }
+  const result = [];
+  for (const [key, override] of Object.entries(config.fieldOverrides)) {
+    if (!override.pgType) {
+      continue;
+    }
+    const defaultName = Array.isArray(override.defaultValue) ? override.defaultValue : typeof override.defaultValue === "string" ? override.defaultValue : key;
+    result.push({
+      key,
+      defaultName,
+      pgType: override.pgType
+    });
+  }
+  return result;
+}
+function sanitizePolicyData(data) {
+  const sanitized = {};
+  for (const [key, value] of Object.entries(data)) {
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    if (typeof value === "string" && value.trim() === "") {
+      continue;
+    }
+    if (Array.isArray(value) && value.length === 0) {
+      continue;
+    }
+    sanitized[key] = value;
+  }
+  return sanitized;
+}
+function injectSchemaFields(policyData, schemaId, policyType) {
+  const config = POLICY_PROVISIONING_CONFIG[policyType];
+  if (!config?.fieldOverrides) {
+    return policyData;
+  }
+  const next = { ...policyData };
+  for (const [key, override] of Object.entries(config.fieldOverrides)) {
+    if (!AUTO_INJECT_SCHEMA_FIELDS.has(key)) {
+      continue;
+    }
+    if (override.hidden && next[key] === void 0) {
+      next[key] = schemaId;
+    }
+  }
+  return next;
+}
+function buildNodeDataForDataNodeType(dataNodeType, policyData) {
+  if (!dataNodeType) {
+    return {};
+  }
+  const data = {};
+  if (dataNodeType === "DataDirectOwner") {
+    if (policyData.entity_field && policyData.entity_field !== "owner_id") {
+      data.owner_field_name = policyData.entity_field;
+    }
+  }
+  if (dataNodeType === "DataEntityMembership") {
+    if (policyData.entity_field && policyData.entity_field !== "entity_id") {
+      data.entity_field_name = policyData.entity_field;
+    }
+  }
+  if (dataNodeType === "DataOwnershipInEntity") {
+    if (policyData.entity_field && policyData.entity_field !== "entity_id") {
+      data.entity_field_name = policyData.entity_field;
+    }
+    if (policyData.anchor_field && policyData.anchor_field !== "owner_id") {
+      data.owner_field_name = policyData.anchor_field;
+    }
+  }
+  return data;
+}
+function buildNodeData(policyType, policyData) {
+  return buildNodeDataForDataNodeType(getDataNodeForPolicy(policyType), policyData);
+}
+
+// src/tables.ts
 function assert2(condition, message) {
   if (!condition) {
     throw new Error(message);
   }
 }
 function getPolicyPrivileges(policy) {
-  const operations = policy.operations?.length ? policy.operations : data.CRUD_OPERATIONS;
-  return operations.map((operation) => data.CRUD_TO_PRIVILEGE[operation]);
+  const operations = policy.operations?.length ? policy.operations : CRUD_OPERATIONS;
+  return operations.map((operation) => CRUD_TO_PRIVILEGE[operation]);
 }
 function getResolvedPolicyData(policy, schemaId) {
-  return data.sanitizePolicyData(
-    data.injectSchemaFields(
+  return sanitizePolicyData(
+    injectSchemaFields(
       {
-        ...data.getPolicyFieldDefaults(policy.policyType),
+        ...getPolicyFieldDefaults(policy.policyType),
         ...policy.policyData ?? {}
       },
       schemaId,
@@ -20380,7 +21047,7 @@ async function ensureBaseTable(db, databaseId, schemaId, tableName, grantRoles,
     tableName,
     useRls,
     grantRoles,
-    grantPrivileges: data.DEFAULT_CRUD_GRANT_PRIVILEGES
+    grantPrivileges: DEFAULT_CRUD_GRANT_PRIVILEGES
   };
   if (inlinePolicy) {
     provisionInput.policyType = inlinePolicy.policyType;
@@ -20479,7 +21146,7 @@ async function createPrimaryKey(db, databaseId, tableId, fieldIds) {
 }
 async function ensurePolicyFields(db, databaseId, tableId, policy, schemaId) {
   const resolvedPolicyData = getResolvedPolicyData(policy, schemaId);
-  const helperFields = data.getFieldsRequiringColumns(policy.policyType);
+  const helperFields = getFieldsRequiringColumns(policy.policyType);
   let createdFields = 0;
   for (const helperField of helperFields) {
     const overrideValue = resolvedPolicyData[helperField.key];
@@ -20501,8 +21168,8 @@ async function attachPolicyToTable(db, databaseId, schemaId, tableId, policy, no
     throw new Error("AuthzComposite is not supported in seeder blueprints yet");
   }
   const resolvedPolicyData = getResolvedPolicyData(policy, schemaId);
-  const nodeType = data.getDataNodeForPolicy(policy.policyType);
-  const nodeData = data.buildNodeData(policy.policyType, resolvedPolicyData);
+  const nodeType = getDataNodeForPolicy(policy.policyType);
+  const nodeData = buildNodeData(policy.policyType, resolvedPolicyData);
   const provisionInput = {
     databaseId,
     schemaId,
@@ -20537,10 +21204,10 @@ async function provisionTable(db, databaseId, schemaId, table, grantRoles) {
     return ensureBaseTable(db, databaseId, schemaId, table.name, grantRoles, false);
   }
   const [firstPolicy, ...remainingPolicies] = policies;
-  const firstPolicyCategory = data.getPolicyCategory(firstPolicy.policyType);
+  const firstPolicyCategory = getPolicyCategory(firstPolicy.policyType);
   const firstPolicyData = getResolvedPolicyData(firstPolicy, schemaId);
-  const firstNodeType = data.getDataNodeForPolicy(firstPolicy.policyType);
-  const firstNodeData = data.buildNodeData(firstPolicy.policyType, firstPolicyData);
+  const firstNodeType = getDataNodeForPolicy(firstPolicy.policyType);
+  const firstNodeData = buildNodeData(firstPolicy.policyType, firstPolicyData);
   const nodeTypesSeen = /* @__PURE__ */ new Set();
   const inlinePolicy = firstPolicyCategory === "has-module" || firstPolicyCategory === "no-fields" || firstPolicyCategory === "needs-table" ? {
     policyType: firstPolicy.policyType,
@@ -20569,7 +21236,7 @@ async function provisionTable(db, databaseId, schemaId, table, grantRoles) {
     outcome.tableModulesCreated += attachResult.tableModulesCreated;
   }
   for (const policy of remainingPolicies) {
-    if (data.getPolicyCategory(policy.policyType) === "needs-fields") {
+    if (getPolicyCategory(policy.policyType) === "needs-fields") {
       await ensurePolicyFields(db, databaseId, outcome.tableId, policy, schemaId);
     }
     const attachResult = await attachPolicyToTable(db, databaseId, schemaId, outcome.tableId, policy, nodeTypesSeen);
@@ -20614,51 +21281,51 @@ async function provisionManyToManyRelation(db, databaseId, schemaId, sourceTable
     throw new Error(`Relation ${relation.junctionTableName} supports at most one junction-table policy`);
   }
   const junctionPolicy = relation.policies?.[0];
-  if (junctionPolicy?.policyType === "AuthzComposite" || data.getPolicyCategory(junctionPolicy?.policyType ?? "AuthzAllowAll") === "needs-fields") {
+  if (junctionPolicy?.policyType === "AuthzComposite" || getPolicyCategory(junctionPolicy?.policyType ?? "AuthzAllowAll") === "needs-fields") {
     throw new Error(`Relation ${relation.junctionTableName} uses an unsupported junction-table policy`);
   }
   const resolvedPolicy = junctionPolicy ?? {
     policyType: "AuthzAllowAll"};
   const policyData = getResolvedPolicyData(resolvedPolicy, schemaId);
-  const derivedNodeType = data.getDataNodeForPolicy(resolvedPolicy.policyType);
-  const baseNodeData = data.buildNodeData(resolvedPolicy.policyType, policyData);
-  const data$1 = {
+  const derivedNodeType = getDataNodeForPolicy(resolvedPolicy.policyType);
+  const baseNodeData = buildNodeData(resolvedPolicy.policyType, policyData);
+  const data = {
     databaseId,
     relationType: "RelationManyToMany",
     sourceTableId,
     targetTableId,
     junctionTableName: relation.junctionTableName,
     grantRoles: ["authenticated"],
-    grantPrivileges: data.DEFAULT_CRUD_GRANT_PRIVILEGES,
+    grantPrivileges: DEFAULT_CRUD_GRANT_PRIVILEGES,
     policyType: resolvedPolicy.policyType,
     policyPermissive: resolvedPolicy.isPermissive ?? true,
     policyData,
     policyRole: resolvedPolicy.roleName?.trim() || "authenticated"
   };
   if (relation.deleteAction) {
-    data$1.deleteAction = relation.deleteAction;
+    data.deleteAction = relation.deleteAction;
   }
   if (relation.useCompositeKey !== void 0) {
-    data$1.useCompositeKey = relation.useCompositeKey;
+    data.useCompositeKey = relation.useCompositeKey;
   }
   if (relation.sourceFieldName) {
-    data$1.sourceFieldName = relation.sourceFieldName;
+    data.sourceFieldName = relation.sourceFieldName;
   }
   if (relation.targetFieldName) {
-    data$1.targetFieldName = relation.targetFieldName;
+    data.targetFieldName = relation.targetFieldName;
   }
   if (derivedNodeType) {
-    data$1.nodeType = derivedNodeType;
+    data.nodeType = derivedNodeType;
     const derivedNodeData = relation.useCompositeKey ? { ...baseNodeData, include_id: false } : baseNodeData;
     if (Object.keys(derivedNodeData).length > 0) {
-      data$1.nodeData = derivedNodeData;
+      data.nodeData = derivedNodeData;
     }
   } else if (!relation.useCompositeKey) {
-    data$1.nodeType = "DataId";
+    data.nodeType = "DataId";
   }
   try {
     const result = await db.relationProvision.create({
-      data: data$1,
+      data,
       select: { id: true, outJunctionTableId: true }
     }).execute();
     if (!result.ok) {
@@ -20922,7 +21589,7 @@ function getTableLookupVariants(value) {
 async function loadMetaTables(client) {
   const response = await client.request(META_QUERY);
   const rawTables = response._meta?.tables?.filter((table) => Boolean(table)) ?? [];
-  const allTables = rawTables.map((table) => data.cleanTable(table));
+  const allTables = rawTables.map((table) => cleanTable(table));
   const byName = /* @__PURE__ */ new Map();
   for (let index = 0; index < rawTables.length; index++) {
     const rawTable = rawTables[index];
@@ -21011,16 +21678,16 @@ async function executeSeedNode(client, node, meta, ctx) {
       ids: []
     };
   }
-  const mutation = data.buildPostGraphileCreate(table, meta.allTables, {
+  const mutation = index_js$1.buildPostGraphileCreate(table, meta.allTables, {
     fieldSelection: { select: ["id"] }
   });
-  const singularName = data.toCamelCaseSingular(node.table, table);
-  const mutationName = data.toCreateMutationName(node.table, table);
+  const singularName = index_js$1.toCamelCaseSingular(node.table, table);
+  const mutationName = index_js$1.toCreateMutationName(node.table, table);
   const results = await batchedAll(generatedRows, async (row) => {
     const input = node.mapInput ? node.mapInput(row, ctx) : row;
     const variables = {
       input: {
-        [singularName]: data.prepareCreateInput(input)
+        [singularName]: prepareCreateInput(input)
       }
     };
     try {