FM / prisma

/home/techb158/balavpn.abdallabala.com/prisma/

/home/techb158/balavpn.abdallabala.com/prisma

Name	Size	Mode	Actions
add-membership.js	996	0644	edit dl rm
check-counts.js	525	0644	edit dl rm
check-org.js	543	0644	edit dl rm
check-project.js	401	0644	edit dl rm
cleanup-dups.js	1913	0644	edit dl rm
import-project-1.js	11325	0644	edit dl rm
import-project.js	11325	0644	edit dl rm
list-projects.js	264	0644	edit dl rm
schema.prisma	18036	0644	edit dl rm
seed-import.json	170983	0644	edit dl rm
seed.js	17790	0644	edit dl rm

Edit: /home/techb158/balavpn.abdallabala.com/prisma/seed.js (17790B)

const fs = require("fs");
const path = require("path");
const bcrypt = require("bcryptjs");
const { PrismaClient } = require("@prisma/client");

const prisma = new PrismaClient();

const CREATE_DEMO = process.env.COSMIC_CREATE_DEMO === "true";

const ROLE_TEMPLATES = [
  { code: "owner", name: "Owner", permissions: ["*"] },
  { code: "admin", name: "Admin", permissions: ["organization:view", "organization:manage", "workspace:manage", "project:read", "project:write", "risk:read", "risk:write", "risk:delete", "mitigation:write", "gate:evaluate", "gate:review", "report:export", "integration:manage", "billing:manage", "audit:read"] },
  { code: "project_manager", name: "Project Manager", permissions: ["organization:view", "project:read", "project:write", "risk:read", "risk:write", "mitigation:write", "gate:evaluate", "report:export", "integration:read", "audit:read"] },
  { code: "risk_owner", name: "Risk Owner", permissions: ["project:read", "risk:read", "risk:write", "mitigation:write", "gate:read"] },
  { code: "governance_reviewer", name: "Governance Reviewer", permissions: ["project:read", "risk:read", "gate:evaluate", "gate:review", "report:export", "audit:read"] },
  { code: "legal_ethics_reviewer", name: "Legal / Ethics Reviewer", permissions: ["project:read", "risk:read", "mitigation:write", "gate:review", "report:export", "audit:read"] },
  { code: "integration_admin", name: "Integration Admin", permissions: ["project:read", "integration:read", "integration:manage", "integration:sync", "oauth:manage", "audit:read"] },
  { code: "viewer", name: "Viewer", permissions: ["organization:view", "project:read", "risk:read", "gate:read", "integration:read", "report:export"] },
  { code: "consultant", name: "Consultant", permissions: ["workspace:manage", "project:read", "project:write", "risk:read", "risk:write", "mitigation:write", "gate:evaluate", "gate:review", "report:export", "audit:read"] }
];

function slug(value) {
  return String(value || "item")
    .toLowerCase()
    .replace(/[^a-z0-9]+/g, "-")
    .replace(/(^-|-$)/g, "");
}

const defaultPassword = process.env.COSMIC_BOOTSTRAP_PASSWORD || "cosmic123";

async function upsertChild(model, projectId, item) {
  try {
    await prisma[model].upsert({
      where: { projectId_name: { projectId, name: item.name } },
      update: item,
      create: { projectId, ...item }
    });
  } catch {
    // Fallback if the unique constraint isn't applied yet
    const existing = await prisma[model].findFirst({ where: { projectId, name: item.name } });
    if (existing) await prisma[model].update({ where: { id: existing.id }, data: item });
    else await prisma[model].create({ data: { projectId, ...item } });
  }
}

async function upsertUser(email, displayName, password, platformRole, roleCode, organizationId) {
  const h = await bcrypt.hash(password || defaultPassword, 12);
  // Never downgrade a platform-level user (SUPER_OWNER/SUPER_ADMIN) to NONE
  const existing = await prisma.user.findUnique({ where: { email } });
  const finalPlatformRole = (existing && existing.platformRole !== "NONE") ? existing.platformRole : (platformRole || "NONE");
  const user = await prisma.user.upsert({
    where: { email },
    update: { displayName, passwordHash: h, platformRole: finalPlatformRole },
    create: { email, displayName, passwordHash: h, platformRole: platformRole || "NONE", emailVerifiedAt: new Date() },
  });

if (organizationId && roleCode) {
    const role = await prisma.role.findUnique({ where: { code: roleCode } });
    if (role) {
      await prisma.membership.upsert({
        where: { organizationId_userId: { organizationId, userId: user.id } },
        update: { roleId: role.id, status: "ACTIVE" },
        create: { organizationId, userId: user.id, roleId: role.id, status: "ACTIVE" },
      }).catch(() => {});
    }
  }
  return user;
}

async function main() {
  for (const role of ROLE_TEMPLATES) {
    await prisma.role.upsert({
      where: { code: role.code },
      update: { name: role.name, permissions: role.permissions },
      create: role
    });
  }

// Bootstrap user from env var (e.g., COSMIC_BOOTSTRAP_EMAIL)
  const bootstrapEmail = process.env.COSMIC_BOOTSTRAP_EMAIL;
  if (bootstrapEmail) {
    await upsertUser(
      bootstrapEmail,
      process.env.COSMIC_BOOTSTRAP_NAME || "COSMIC Platform Owner",
      defaultPassword,
      "SUPER_OWNER",
      null,
      null
    );
  }

// Always create the standard demo platform users
  const superOwner = await upsertUser("super-owner@cosmic.local", "COSMIC Platform Owner", defaultPassword, "SUPER_OWNER", null, null);
  const superAdmin = await upsertUser("super-admin@cosmic.local", "Super Admin", "super123", "SUPER_ADMIN", null, null);

// Cleanup: remove orphaned orgs from any previous seed runs
  await prisma.$executeRawUnsafe(`DELETE FROM "Organization" WHERE id NOT IN (SELECT "organizationId" FROM "Membership")`).catch(() => {});

if (CREATE_DEMO) {
    // Demo organization with org-level users
    const organization = await prisma.organization.upsert({
      where: { slug: "cosmic-demo" },
      update: {},
      create: {
        name: "COSMIC Demo Organization",
        slug: "cosmic-demo",
        status: "TRIAL",
        planCode: "pilot",
        manualBilling: true
      }
    });

// Grant Super Admin access to this organization
    await prisma.organizationAccess.upsert({
      where: { userId_organizationId: { userId: superAdmin.id, organizationId: organization.id } },
      update: {},
      create: { userId: superAdmin.id, organizationId: organization.id }
    }).catch(() => {});

await prisma.subscription.create({
      data: {
        organizationId: organization.id,
        source: "MANUAL",
        status: "TRIALING",
        planCode: "pilot",
        userLimit: 10,
        projectLimit: 5,
        reportLimitMonthly: 100,
        integrationLimit: 4,
        adminOverride: true
      }
    }).catch(() => null);

const workspace = await prisma.workspace.upsert({
      where: { organizationId_slug: { organizationId: organization.id, slug: "ai-risk-governance" } },
      update: {},
      create: {
        organizationId: organization.id,
        name: "AI Risk Governance",
        slug: "ai-risk-governance",
        type: "B2B_TEAM",
        status: "TRIAL"
      }
    });

// Org-level users (members of the demo org)
    const orgOwner = await upsertUser("org-owner@cosmic.local", "Organization Owner", "orgowner123", "NONE", "owner", organization.id);
    // Only create org-level owner@ if it wasn't already created as SUPER_OWNER by bootstrap env var
    const ownerExisting = await prisma.user.findUnique({ where: { email: "owner@cosmic.local" } });
    if (!ownerExisting || ownerExisting.platformRole === "NONE") {
      await upsertUser("owner@cosmic.local", "Owner", "owner123", "NONE", "owner", organization.id);
    }
    await upsertUser("admin@cosmic.local", "COSMIC Admin", "admin123", "NONE", "admin", organization.id);
    await upsertUser("pm@cosmic.local", "Project Manager", "pm123", "NONE", "project_manager", organization.id);
    await upsertUser("risk-owner@cosmic.local", "Risk Owner", "risk123", "NONE", "risk_owner", organization.id);
    await upsertUser("viewer@cosmic.local", "Read-Only Viewer", "view123", "NONE", "viewer", organization.id);

// Seed project data
    const sourcePath = path.join(__dirname, "..", "..", "data", "database.json");
    let sourceData = null;
    try {
      if (fs.existsSync(sourcePath)) {
        sourceData = JSON.parse(fs.readFileSync(sourcePath, "utf8"));
      }
    } catch (e) {
      console.warn(`Could not read seed data file: ${e.message}`);
    }

const riskIdMap = new Map();
    const mitigationIdMap = new Map();

await prisma.$executeRawUnsafe(`DELETE FROM "LifecyclePhase" lp USING "LifecyclePhase" lp2 WHERE lp.id > lp2.id AND lp."projectId" = lp2."projectId" AND lp.name = lp2.name`).catch(() => {});
    for (const ph of [
      { name: "Design", status: "Completed", readinessScore: 95, sequence: 1 },
      { name: "Development", status: "Completed", readinessScore: 80, sequence: 2 },
      { name: "Testing", status: "In Progress", readinessScore: 55, sequence: 3 },
      { name: "Deployment", status: "Pending", readinessScore: 15, sequence: 4 },
    ]) await upsertChild("lifecyclePhase", project.id, ph);

await prisma.$executeRawUnsafe(`DELETE FROM "Indicator" lp USING "Indicator" lp2 WHERE lp.id > lp2.id AND lp."projectId" = lp2."projectId" AND lp.name = lp2.name`).catch(() => {});
    await prisma.$executeRawUnsafe(`DELETE FROM "Experiment" lp USING "Experiment" lp2 WHERE lp.id > lp2.id AND lp."projectId" = lp2."projectId" AND lp.name = lp2.name`).catch(() => {});

for (const ind of [
      { name: "Fairness Score", dimension: "Technical", measurand: "Demographic parity ratio", unit: "ratio", target: ">=0.8", interpretationRule: "Higher is better" },
      { name: "Model Accuracy", dimension: "Technical", measurand: "Accuracy rate", unit: "%", target: ">=90", interpretationRule: "Higher is better" },
      { name: "Response Latency", dimension: "Operational", measurand: "P95 response time", unit: "ms", target: "<2000", interpretationRule: "Lower is better" },
    ]) await upsertChild("indicator", project.id, ind);

const existingReport = await prisma.reportExport.findFirst({ where: { projectId: project.id } });
    if (!existingReport) {
      await prisma.reportExport.create({
        data: { workspaceId: workspace.id, projectId: project.id, reportType: "executive.html", format: "html", status: "Generated", metadata: { note: "Seeded demo report" }, createdById: orgOwner.id }
      }).catch(() => {});
    }

await prisma.integration.create({
      data: {
        workspaceId: workspace.id,
        provider: "TRELLO",
        workspaceName: "AI Risk Board",
        baseUrl: "https://trello.com",
        authMode: "API_KEY",
        connectionStatus: "NEEDS_CONFIGURATION",
        syncDirection: "COSMIC to PM",
        liveEnabled: false,
      }
    }).catch(() => {});

await prisma.auditEvent.create({
      data: {
        organizationId: organization.id,
        workspaceId: workspace.id,
        projectId: project.id,
        actorUserId: orgOwner.id,
        entityType: "Seed",
        entityId: project.id,
        action: "seed-demo-workspace",
        afterJson: { risks: riskIdMap.size }
      }
    });

console.log(`Seeded ${organization.name} with workspace ${workspace.name} and ${riskIdMap.size} risks.`);
    console.log("");
    console.log("=== Organization-level users (members of COSMIC Demo Org) ===");
    console.log("  owner@cosmic.local / owner123  →  Organization Owner");
    console.log("  org-owner@cosmic.local / orgowner123  →  Organization Owner");
    console.log("  admin@cosmic.local / admin123  →  Organization Admin");
    console.log("  pm@cosmic.local / pm123  →  Project Manager");
    console.log("  risk-owner@cosmic.local / risk123  →  Risk Owner");
    console.log("  viewer@cosmic.local / view123  →  Viewer");
  }

console.log("=== Platform-level users (no org membership) ===");
  console.log("  super-owner@cosmic.local / cosmic123  →  Super Owner");
  console.log("  super-admin@cosmic.local / super123  →  Super Admin");
  if (!CREATE_DEMO) {
    console.log("");
    console.log("=== No demo organization created ===");
    console.log("  Set COSMIC_CREATE_DEMO=true to seed demo data.");
    console.log("  Log in as Super Owner to create your own organizations and projects.");
  }
}

main()
  .catch(error => {
    console.error(error);
    process.exit(1);
  })
  .finally(async () => {
    await prisma.$disconnect();
  });

cmd: