@constructive-io/seeder 0.5.0 → 0.5.2

package/dist/bin.js

@@ -7,7 +7,14 @@ import { Inquirerer } from 'inquirerer';
 import { parseType, print } from '@0no-co/graphql.web';
 import * as t from 'gql-ast';
 import { gql, GraphQLClient } from 'graphql-request';
-import { getPolicyCategory, getDataNodeForPolicy, buildNodeData, cleanTable, buildPostGraphileCreate, toCamelCaseSingular, toCreateMutationName, sanitizePolicyData, injectSchemaFields, getPolicyFieldDefaults, CRUD_OPERATIONS, CRUD_TO_PRIVILEGE, getFieldsRequiringColumns, DEFAULT_CRUD_GRANT_PRIVILEGES, prepareCreateInput } from '@constructive-io/data';
+import '@constructive-io/graphql-query/client/index.js';
+import { buildPostGraphileCreate, toCamelCaseSingular, toCreateMutationName } from '@constructive-io/graphql-query/generators/index.js';
+import '@constructive-io/graphql-query/query-builder.js';
+import '@constructive-io/graphql-query/types/core.js';
+import '@constructive-io/graphql-query/ast.js';
+import '@constructive-io/graphql-query/custom-ast.js';
+import '@constructive-io/graphql-query/meta-object/convert.js';
+import '@constructive-io/graphql-query/meta-object/validate.js';
 import { readFile } from 'fs/promises';
 import path from 'path';
 import { pathToFileURL } from 'url';
@@ -15,7 +22,7 @@ import { z } from 'zod';
 
 // package.json
 var package_default = {
-  version: "0.5.0"};
+  version: "0.5.2"};
 
 // src/blueprints/base.ts
 function getProvisionedTableNames(blueprint) {
@@ -20271,6 +20278,666 @@ async function provisionDatabase(db, options) {
   }
   return provisionResult;
 }
+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);