@trycompai/db 1.0.0

package/dist/prisma/seed/seed.js

@@ -0,0 +1,160 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("@prisma/client");
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const frameworkEditorSchemas_1 = require("./frameworkEditorSchemas");
+const prisma = new client_1.PrismaClient();
+async function seedJsonFiles(subDirectory) {
+    const directoryPath = node_path_1.default.join(__dirname, subDirectory);
+    console.log(`Starting to seed files from: ${directoryPath}`);
+    const files = await promises_1.default.readdir(directoryPath);
+    const jsonFiles = files.filter((file) => file.endsWith('.json'));
+    for (const jsonFile of jsonFiles) {
+        try {
+            const filePath = node_path_1.default.join(directoryPath, jsonFile);
+            const jsonContent = await promises_1.default.readFile(filePath, 'utf-8');
+            const jsonData = JSON.parse(jsonContent);
+            if (!Array.isArray(jsonData) || jsonData.length === 0) {
+                console.log(`Skipping empty or invalid JSON file: ${jsonFile}`);
+                continue;
+            }
+            if (subDirectory === 'primitives') {
+                const modelNameForPrisma = jsonFile.replace('.json', '');
+                const prismaModelKey = modelNameForPrisma.charAt(0).toLowerCase() + modelNameForPrisma.slice(1);
+                const zodModelKey = modelNameForPrisma;
+                const prismaAny = prisma;
+                if (!prismaAny[prismaModelKey] ||
+                    typeof prismaAny[prismaModelKey].createMany !== 'function') {
+                    console.warn(`Model ${prismaModelKey} not found on Prisma client or does not support createMany. Skipping ${jsonFile}.`);
+                    continue;
+                }
+                const zodSchema = frameworkEditorSchemas_1.frameworkEditorModelSchemas[zodModelKey];
+                if (!zodSchema) {
+                    console.warn(`Zod schema not found for model ${String(zodModelKey)}. Skipping validation for ${jsonFile}.`);
+                }
+                else {
+                    console.log(`Validating ${jsonData.length} records from ${jsonFile} against ${String(zodModelKey)} schema...`);
+                    for (const item of jsonData) {
+                        try {
+                            zodSchema.parse(item);
+                        }
+                        catch (validationError) {
+                            console.error(`Validation failed for an item in ${jsonFile} for model ${String(zodModelKey)}:`, item);
+                            console.error('Validation errors:', validationError);
+                            throw new Error(`Data validation failed for ${jsonFile}.`);
+                        }
+                    }
+                    console.log(`Validation successful for ${jsonFile}.`);
+                }
+                const processedData = jsonData.map((item) => {
+                    const newItem = { ...item };
+                    if (newItem.createdAt && typeof newItem.createdAt === 'string') {
+                        newItem.createdAt = new Date(newItem.createdAt);
+                    }
+                    if (newItem.updatedAt && typeof newItem.updatedAt === 'string') {
+                        newItem.updatedAt = new Date(newItem.updatedAt);
+                    }
+                    return newItem;
+                });
+                console.log(`Seeding ${processedData.length} records from ${jsonFile} into ${prismaModelKey}...`);
+                // Use upsert to update existing records instead of skipping them
+                for (const record of processedData) {
+                    await prismaAny[prismaModelKey].upsert({
+                        where: { id: record.id },
+                        create: record,
+                        update: record,
+                    });
+                }
+                console.log(`Finished seeding ${jsonFile} from primitives.`);
+            }
+            else if (subDirectory === 'relations') {
+                // Expected filename format: _ModelAToModelB.json
+                if (!jsonFile.startsWith('_') || !jsonFile.includes('To')) {
+                    console.warn(`Skipping relation file with unexpected format: ${jsonFile}`);
+                    continue;
+                }
+                const modelNamesPart = jsonFile.substring(1, jsonFile.indexOf('.json'));
+                const [modelANamePascal, modelBNamePascal] = modelNamesPart.split('To');
+                if (!modelANamePascal || !modelBNamePascal) {
+                    console.warn(`Could not parse model names from relation file: ${jsonFile}`);
+                    continue;
+                }
+                const prismaModelAName = modelANamePascal.charAt(0).toLowerCase() + modelANamePascal.slice(1);
+                // Infer relation field name on ModelA: pluralized, camelCased ModelB name
+                // e.g., if ModelB is FrameworkEditorPolicyTemplate, relation field is frameworkEditorPolicyTemplates
+                // This is a common convention, but might need adjustment based on actual schema
+                let relationFieldNameOnModelA = modelBNamePascal.charAt(0).toLowerCase() + modelBNamePascal.slice(1);
+                if (!relationFieldNameOnModelA.endsWith('s')) {
+                    // basic pluralization
+                    relationFieldNameOnModelA += 's';
+                }
+                // Special handling for 'Requirement' -> 'requirements' (already plural)
+                // and other specific cases if 's' isn't the right pluralization.
+                // For now, using a direct map for known cases from the user's file names.
+                if (modelBNamePascal === 'FrameworkEditorPolicyTemplate') {
+                    relationFieldNameOnModelA = 'policyTemplates';
+                }
+                else if (modelBNamePascal === 'FrameworkEditorRequirement') {
+                    relationFieldNameOnModelA = 'requirements';
+                }
+                else if (modelBNamePascal === 'FrameworkEditorTaskTemplate') {
+                    relationFieldNameOnModelA = 'taskTemplates';
+                }
+                const prismaAny = prisma;
+                if (!prismaAny[prismaModelAName] ||
+                    typeof prismaAny[prismaModelAName].update !== 'function') {
+                    console.warn(`Model ${prismaModelAName} not found on Prisma client or does not support update. Skipping ${jsonFile}.`);
+                    continue;
+                }
+                console.log(`Processing relations from ${jsonFile} for ${prismaModelAName} to connect via ${relationFieldNameOnModelA}...`);
+                let connectionsMade = 0;
+                for (const relationItem of jsonData) {
+                    if (!relationItem.A || !relationItem.B) {
+                        console.warn(`Skipping invalid relation item in ${jsonFile}:`, relationItem);
+                        continue;
+                    }
+                    const idA = relationItem.A;
+                    const idB = relationItem.B;
+                    try {
+                        await prismaAny[prismaModelAName].update({
+                            where: { id: idA },
+                            data: {
+                                [relationFieldNameOnModelA]: {
+                                    connect: { id: idB },
+                                },
+                            },
+                        });
+                        connectionsMade++;
+                    }
+                    catch (error) {
+                        console.error(`Failed to connect ${prismaModelAName} (${idA}) with ${modelBNamePascal} (${idB}) from ${jsonFile}:`, error);
+                        // Decide if one error should stop the whole process for this file or continue
+                    }
+                }
+                console.log(`Finished processing ${jsonFile}. Made ${connectionsMade} connections.`);
+            }
+        }
+        catch (error) {
+            console.error(`Error processing ${jsonFile}:`, error);
+            throw error;
+        }
+    }
+}
+async function main() {
+    try {
+        await seedJsonFiles('primitives');
+        await seedJsonFiles('relations');
+        await prisma.$disconnect();
+        console.log('Seeding completed successfully for primitives and relations.');
+    }
+    catch (error) {
+        console.error('Seeding failed:', error);
+        await prisma.$disconnect();
+        process.exit(1);
+    }
+}
+main();

package/dist/prisma/seed/seed.ts

@@ -0,0 +1,192 @@
+import { PrismaClient } from '@prisma/client';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { frameworkEditorModelSchemas } from './frameworkEditorSchemas';
+
+const prisma = new PrismaClient();
+
+async function seedJsonFiles(subDirectory: string) {
+  const directoryPath = path.join(__dirname, subDirectory);
+  console.log(`Starting to seed files from: ${directoryPath}`);
+  const files = await fs.readdir(directoryPath);
+  const jsonFiles = files.filter((file) => file.endsWith('.json'));
+
+  for (const jsonFile of jsonFiles) {
+    try {
+      const filePath = path.join(directoryPath, jsonFile);
+      const jsonContent = await fs.readFile(filePath, 'utf-8');
+      const jsonData = JSON.parse(jsonContent);
+
+      if (!Array.isArray(jsonData) || jsonData.length === 0) {
+        console.log(`Skipping empty or invalid JSON file: ${jsonFile}`);
+        continue;
+      }
+
+      if (subDirectory === 'primitives') {
+        const modelNameForPrisma = jsonFile.replace('.json', '');
+        const prismaModelKey =
+          modelNameForPrisma.charAt(0).toLowerCase() + modelNameForPrisma.slice(1);
+        const zodModelKey = modelNameForPrisma as keyof typeof frameworkEditorModelSchemas;
+
+        const prismaAny = prisma as any;
+        if (
+          !prismaAny[prismaModelKey] ||
+          typeof prismaAny[prismaModelKey].createMany !== 'function'
+        ) {
+          console.warn(
+            `Model ${prismaModelKey} not found on Prisma client or does not support createMany. Skipping ${jsonFile}.`,
+          );
+          continue;
+        }
+
+        const zodSchema = frameworkEditorModelSchemas[zodModelKey];
+        if (!zodSchema) {
+          console.warn(
+            `Zod schema not found for model ${String(zodModelKey)}. Skipping validation for ${jsonFile}.`,
+          );
+        } else {
+          console.log(
+            `Validating ${jsonData.length} records from ${jsonFile} against ${String(zodModelKey)} schema...`,
+          );
+          for (const item of jsonData) {
+            try {
+              zodSchema.parse(item);
+            } catch (validationError) {
+              console.error(
+                `Validation failed for an item in ${jsonFile} for model ${String(zodModelKey)}:`,
+                item,
+              );
+              console.error('Validation errors:', validationError);
+              throw new Error(`Data validation failed for ${jsonFile}.`);
+            }
+          }
+          console.log(`Validation successful for ${jsonFile}.`);
+        }
+
+        const processedData = jsonData.map((item) => {
+          const newItem = { ...item };
+          if (newItem.createdAt && typeof newItem.createdAt === 'string') {
+            newItem.createdAt = new Date(newItem.createdAt);
+          }
+          if (newItem.updatedAt && typeof newItem.updatedAt === 'string') {
+            newItem.updatedAt = new Date(newItem.updatedAt);
+          }
+          return newItem;
+        });
+
+        console.log(
+          `Seeding ${processedData.length} records from ${jsonFile} into ${prismaModelKey}...`,
+        );
+
+        // Use upsert to update existing records instead of skipping them
+        for (const record of processedData) {
+          await prismaAny[prismaModelKey].upsert({
+            where: { id: record.id },
+            create: record,
+            update: record,
+          });
+        }
+
+        console.log(`Finished seeding ${jsonFile} from primitives.`);
+      } else if (subDirectory === 'relations') {
+        // Expected filename format: _ModelAToModelB.json
+        if (!jsonFile.startsWith('_') || !jsonFile.includes('To')) {
+          console.warn(`Skipping relation file with unexpected format: ${jsonFile}`);
+          continue;
+        }
+
+        const modelNamesPart = jsonFile.substring(1, jsonFile.indexOf('.json'));
+        const [modelANamePascal, modelBNamePascal] = modelNamesPart.split('To');
+
+        if (!modelANamePascal || !modelBNamePascal) {
+          console.warn(`Could not parse model names from relation file: ${jsonFile}`);
+          continue;
+        }
+
+        const prismaModelAName =
+          modelANamePascal.charAt(0).toLowerCase() + modelANamePascal.slice(1);
+        // Infer relation field name on ModelA: pluralized, camelCased ModelB name
+        // e.g., if ModelB is FrameworkEditorPolicyTemplate, relation field is frameworkEditorPolicyTemplates
+        // This is a common convention, but might need adjustment based on actual schema
+        let relationFieldNameOnModelA =
+          modelBNamePascal.charAt(0).toLowerCase() + modelBNamePascal.slice(1);
+        if (!relationFieldNameOnModelA.endsWith('s')) {
+          // basic pluralization
+          relationFieldNameOnModelA += 's';
+        }
+
+        // Special handling for 'Requirement' -> 'requirements' (already plural)
+        // and other specific cases if 's' isn't the right pluralization.
+        // For now, using a direct map for known cases from the user's file names.
+        if (modelBNamePascal === 'FrameworkEditorPolicyTemplate') {
+          relationFieldNameOnModelA = 'policyTemplates';
+        } else if (modelBNamePascal === 'FrameworkEditorRequirement') {
+          relationFieldNameOnModelA = 'requirements';
+        } else if (modelBNamePascal === 'FrameworkEditorTaskTemplate') {
+          relationFieldNameOnModelA = 'taskTemplates';
+        }
+
+        const prismaAny = prisma as any;
+        if (
+          !prismaAny[prismaModelAName] ||
+          typeof prismaAny[prismaModelAName].update !== 'function'
+        ) {
+          console.warn(
+            `Model ${prismaModelAName} not found on Prisma client or does not support update. Skipping ${jsonFile}.`,
+          );
+          continue;
+        }
+
+        console.log(
+          `Processing relations from ${jsonFile} for ${prismaModelAName} to connect via ${relationFieldNameOnModelA}...`,
+        );
+        let connectionsMade = 0;
+        for (const relationItem of jsonData) {
+          if (!relationItem.A || !relationItem.B) {
+            console.warn(`Skipping invalid relation item in ${jsonFile}:`, relationItem);
+            continue;
+          }
+          const idA = relationItem.A;
+          const idB = relationItem.B;
+
+          try {
+            await prismaAny[prismaModelAName].update({
+              where: { id: idA },
+              data: {
+                [relationFieldNameOnModelA]: {
+                  connect: { id: idB },
+                },
+              },
+            });
+            connectionsMade++;
+          } catch (error) {
+            console.error(
+              `Failed to connect ${prismaModelAName} (${idA}) with ${modelBNamePascal} (${idB}) from ${jsonFile}:`,
+              error,
+            );
+            // Decide if one error should stop the whole process for this file or continue
+          }
+        }
+        console.log(`Finished processing ${jsonFile}. Made ${connectionsMade} connections.`);
+      }
+    } catch (error) {
+      console.error(`Error processing ${jsonFile}:`, error);
+      throw error;
+    }
+  }
+}
+
+async function main() {
+  try {
+    await seedJsonFiles('primitives');
+    await seedJsonFiles('relations');
+    await prisma.$disconnect();
+    console.log('Seeding completed successfully for primitives and relations.');
+  } catch (error: unknown) {
+    console.error('Seeding failed:', error);
+    await prisma.$disconnect();
+    process.exit(1);
+  }
+}
+
+main();

package/dist/types.d.mts

@@ -0,0 +1 @@
+export * from '@prisma/client';

package/dist/types.d.ts

@@ -0,0 +1 @@
+export * from '@prisma/client';

package/dist/types.js

@@ -0,0 +1,24 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);
+__reExport(types_exports, require("@prisma/client"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("@prisma/client")
+});

package/dist/types.mjs

@@ -0,0 +1,2 @@
+// src/types.ts
+export * from "@prisma/client";

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@trycompai/db",
+  "version": "1.0.0",
+  "description": "Database package with Prisma client and schema for Comp AI",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/**",
+    "prisma/**",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/types.mjs",
+      "require": "./dist/types.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.mjs",
+      "require": "./dist/client.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/types.ts --format cjs,esm --dts && bun run db:generate",
+    "clean": "rm -rf .turbo node_modules dist",
+    "db:generate": "bunx prisma generate",
+    "db:migrate": "bunx prisma migrate dev",
+    "db:push": "bunx prisma db push",
+    "db:seed": "bunx prisma db seed",
+    "db:studio": "bunx prisma studio",
+    "dev": "tsup src/index.ts src/types.ts --format cjs,esm --watch --dts",
+    "docker:clean": "docker-compose down -v",
+    "docker:down": "docker-compose down",
+    "docker:up": "docker-compose up -d",
+    "lint": "prettier --check 'src/**/*.{ts,tsx,js,jsx,json}' 'prisma/**/*.prisma' && tsc --noEmit",
+    "postbuild": "cp -r prisma dist/ || echo 'No prisma directory to copy'",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@prisma/client": "6.9.0"
+  },
+  "devDependencies": {
+    "@comp/tsconfig": "workspace:*",
+    "prisma": "^6.9.0",
+    "ts-node": "^10.9.2",
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.3"
+  },
+  "prisma": {
+    "schema": "prisma",
+    "seed": "ts-node prisma/seed/seed.ts"
+  },
+  "keywords": [
+    "prisma",
+    "database",
+    "postgresql",
+    "comp-ai"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/comp-ai/comp.git",
+    "directory": "packages/db"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/prisma/functionDefinition.sql

@@ -0,0 +1,18 @@
+-- Create function to generate prefixed CUID with sortable timestamp (compact)
+CREATE OR REPLACE FUNCTION generate_prefixed_cuid(prefix text)
+RETURNS text AS $$
+DECLARE
+    timestamp_hex text;
+    random_hex text;
+BEGIN
+    -- Generate timestamp component (seconds since epoch) as hex
+    timestamp_hex = LOWER(TO_HEX(EXTRACT(EPOCH FROM NOW())::BIGINT));
+
+    -- Generate 8 random bytes and encode as hex (16 characters)
+    -- Ensure we call the function from the correct schema if pgcrypto is installed elsewhere
+    random_hex = encode(gen_random_bytes(8), 'hex');
+
+    -- Combine prefix, timestamp, and random hex string
+    RETURN prefix || '_' || timestamp_hex || random_hex;
+END;
+$$ LANGUAGE plpgsql;