prisma-client-php 0.0.1 → 0.0.3

package/README.md

@@ -28,7 +28,9 @@ Follow these steps to install and set up Prisma Client PHP:
    npx create-prisma-php-app@latest
    ```
 
-3. **Generate Prisma Client PHP classes** by running:
+3. **Remember to chose Prisma PHP ORM when prompted**.
+
+4. **Generate Prisma Client PHP classes** by running:
 
    ```bash
    npx ppo generate
@@ -36,6 +38,20 @@ Follow these steps to install and set up Prisma Client PHP:
 
 This command will convert your `schema.prisma` models into PHP classes, enabling you to interact with your database using these generated classes.
 
+## Adding Prisma Client PHP to an Existing Prisma PHP Project
+
+If you already have a Prisma PHP project and want to integrate Prisma Client PHP, follow these steps:
+
+1. **Open your terminal**.
+
+2. **Install Prisma Client PHP** by running the following command:
+
+   ```bash
+   npx ppo init
+   ```
+
+This command will install all the necessary packages required for Prisma Client PHP to function within your existing project.
+
 ## Features
 
 - **Auto-Generated PHP Classes**: Prisma Client PHP automatically generates PHP classes based on your Prisma schema.

package/dist/index.js

@@ -2,42 +2,44 @@
 import chalk from "chalk";
 import fs from "fs";
 import path from "path";
-import { fileURLToPath, pathToFileURL } from "url";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
+import { pathToFileURL } from "url";
+import { getFileMeta } from "./utils.js";
+const { __dirname } = getFileMeta();
 const args = process.argv.slice(2);
-const command = args.join(" ");
 const commandsToExecute = {
-    generate: "generate",
+  generate: "generate",
+  init: "init",
 };
-const executeFile = async (fileName) => {
-    const filePath = path.join(__dirname, fileName);
-    if (!fs.existsSync(filePath)) {
-        console.error(chalk.red(`File '${fileName}' not found.`));
-        process.exit(1);
-    }
-    try {
-        const module = await import(pathToFileURL(filePath).toString());
-        if (module.default) {
-            module.default();
-        }
-    }
-    catch (error) {
-        console.error("Error executing file:", error);
+const executeFile = async (fileName, extraArgs = []) => {
+  const filePath = path.join(__dirname, fileName);
+  if (!fs.existsSync(filePath)) {
+    console.error(chalk.red(`File '${fileName}' not found.`));
+    process.exit(1);
+  }
+  try {
+    const module = await import(pathToFileURL(filePath).toString());
+    if (module.default) {
+      module.default(extraArgs); // Pass extraArgs (even if empty)
     }
+  } catch (error) {
+    console.error("Error executing file:", error);
+  }
 };
 const main = async () => {
-    if (args.length === 0) {
-        console.log("No command provided.");
-        return;
-    }
-    if (commandsToExecute.generate === command) {
-        await executeFile("generate.js");
-    }
-    else {
-        console.log(chalk.red("Invalid command. Use: npx ppo generate"));
-    }
+  if (args.length === 0) {
+    console.log("No command provided.");
+    return;
+  }
+  const commandName = args[0]; // First argument is the command (e.g., "init" or "generate")
+  const extraArgs = args.slice(1); // Capture any additional arguments (e.g., "--prisma-php")
+  if (commandsToExecute.generate === commandName) {
+    await executeFile("generate.js", extraArgs);
+  } else if (commandsToExecute.init === commandName) {
+    await executeFile("init.js", extraArgs);
+  } else {
+    console.log(chalk.red("Invalid command. Use: npx ppo generate"));
+  }
 };
 main().catch((error) => {
-    console.error("Unhandled error in main function:", error);
+  console.error("Unhandled error in main function:", error);
 });

package/dist/init.js

@@ -0,0 +1,158 @@
+import fs from "fs";
+import path from "path";
+import { execSync } from "child_process";
+import { getFileMeta } from "./utils.js";
+const { __dirname } = getFileMeta();
+/**
+ * Recursively copies all files and folders from `src` to `dest`,
+ * overwriting existing files if they already exist.
+ *
+ * The `base` parameter represents the original root of the copy.
+ * It is used for computing a relative path for cleaner logging.
+ */
+function copyRecursiveSync(src, dest, base = src) {
+  if (!fs.existsSync(src)) {
+    console.error(`Source folder does not exist: ${src}`);
+    return;
+  }
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyRecursiveSync(srcPath, destPath, base);
+    } else {
+      // Compute the relative path for logging
+      const relative = path.relative(base, srcPath);
+      const display = path.join(path.basename(base), relative);
+      // Copy the file (this will overwrite if it exists)
+      fs.copyFileSync(srcPath, destPath);
+      console.log(`Copied file: ${display}`);
+    }
+  }
+}
+// Configuration for directories to copy (copying the whole directory recursively)
+const directoriesToCopy = [
+  {
+    srcFolder: path.join(__dirname, "src"),
+    destFolder: path.join(process.cwd(), "src"),
+  },
+  {
+    srcFolder: path.join(__dirname, "settings"),
+    destFolder: path.join(process.cwd(), "settings"),
+  },
+  {
+    srcFolder: path.join(__dirname, "prisma"),
+    destFolder: path.join(process.cwd(), "prisma"),
+  },
+];
+/**
+ * Installs specified packages using npm in the current working directory.
+ */
+function installPackages() {
+  const packages = [
+    "prisma@^6.4.1",
+    "@prisma/client@^6.4.1",
+    "@prisma/internals@^6.4.1",
+  ];
+  const packagesStr = packages.join(" ");
+  try {
+    console.log(`Installing packages: ${packagesStr}`);
+    execSync(`npm install ${packagesStr}`, {
+      stdio: "inherit",
+      cwd: process.cwd(),
+    });
+    console.log("Packages installed successfully.");
+  } catch (error) {
+    console.error("Error installing packages:", error);
+  }
+}
+/**
+ * Runs the `npx prisma init` command to initialize Prisma.
+ * If the prisma folder already exists, the command is skipped.
+ */
+function initPrisma() {
+  const prismaFolderPath = path.join(process.cwd(), "prisma");
+  if (fs.existsSync(prismaFolderPath)) {
+    console.warn("Prisma folder already exists. Skipping prisma init.");
+    return;
+  }
+  try {
+    console.log("Initializing Prisma...");
+    execSync(`npx prisma init`, {
+      stdio: "inherit",
+      cwd: process.cwd(),
+    });
+    console.log("Prisma initialized successfully.");
+  } catch (error) {
+    console.error("Error initializing Prisma:", error);
+  }
+}
+/**
+ * Updates the composer.json file by adding "calicastle/cuid": "^2.0.0" to its require section.
+ */
+async function updateComposerJson(baseDir) {
+  const composerJsonPath = path.join(baseDir, "composer.json");
+  let composerJson;
+  if (fs.existsSync(composerJsonPath)) {
+    const composerJsonContent = fs.readFileSync(composerJsonPath, "utf8");
+    composerJson = JSON.parse(composerJsonContent);
+  } else {
+    console.error("composer.json does not exist.");
+    return;
+  }
+  composerJson.require = {
+    ...composerJson.require,
+    "calicastle/cuid": "^2.0.0",
+  };
+  fs.writeFileSync(composerJsonPath, JSON.stringify(composerJson, null, 2));
+  console.log("composer.json updated successfully.");
+}
+/**
+ * Installs the Composer package "calicastle/cuid": "^2.0.0" using the require command.
+ */
+function runComposerInstall() {
+  try {
+    console.log("Installing Composer package calicastle/cuid...");
+    execSync(
+      `C:\\xampp\\php\\php.exe C:\\ProgramData\\ComposerSetup\\bin\\composer.phar require calicastle/cuid:^2.0.0`,
+      {
+        stdio: "inherit",
+      }
+    );
+    console.log("Composer package calicastle/cuid installed successfully.");
+  } catch (error) {
+    console.error("Error installing Composer package calicastle/cuid:", error);
+  }
+}
+/**
+ * Main execution flow.
+ *
+ * If the flag "--prisma-php" is passed, it will update composer.json.
+ * Otherwise, it will run Composer install to install the package.
+ * Then, it proceeds with npm package installation, Prisma initialization, and file copying.
+ */
+async function main() {
+  const isPrismaPHP = process.argv.includes("--prisma-php");
+  if (isPrismaPHP) {
+    // Always update composer.json
+    await updateComposerJson(process.cwd());
+  } else {
+    // Install the Composer package "calicastle/cuid": "^2.0.0"
+    runComposerInstall();
+  }
+  installPackages();
+  initPrisma();
+  directoriesToCopy.forEach((config) => {
+    // Pass the srcFolder as the base for computing relative paths in the log
+    copyRecursiveSync(config.srcFolder, config.destFolder, config.srcFolder);
+  });
+  console.log("Finished copying directories.");
+}
+// Run the main function
+main().catch((error) => {
+  console.error("Error during execution:", error);
+});

package/dist/prisma/schema.prisma

@@ -0,0 +1,35 @@
+// This is your Prisma schema file,
+// learn more about it in the docs: https://pris.ly/d/prisma-schema
+
+// Looking for ways to speed up your queries, or scale easily with your serverless or edge functions?
+// Try Prisma Accelerate: https://pris.ly/cli/accelerate-init
+
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+
+model User {
+  id            String    @id @default(cuid())
+  name          String?
+  email         String?   @unique
+  password      String?
+  emailVerified DateTime?
+  image         String?
+  createdAt     DateTime  @default(now())
+  updatedAt     DateTime  @updatedAt
+
+  roleId   Int?
+  userRole UserRole? @relation(fields: [roleId], references: [id])
+}
+
+model UserRole {
+  id   Int    @id @default(autoincrement())
+  name String @unique
+
+  user User[]
+}

package/dist/prisma/seed.ts

@@ -0,0 +1,74 @@
+// import { PrismaClient } from "@prisma/client";
+
+// const prisma = new PrismaClient();
+
+// // UserRole
+// const userRoleData = [
+//   {
+//     name: "Admin",
+//   },
+//   {
+//     name: "User",
+//   },
+// ];
+
+// // User
+// const userData = [
+//   {
+//     name: "Juan",
+//     email: "j@gmail.com",
+//     password: "$2b$10$mgjotYzIXwrK1MCWmu4tgeUVnLcb.qzvqwxOq4FXEL8k2obwXivDi", // TODO: template password 1234 (bcrypt) testing only
+//     roleId: 1,
+//   },
+// ];
+
+// async function main() {
+  // ========================================
+  // Code for PostgreSQL
+  // ----------------------------------------
+  // UserRole
+  // ----------------------------------------
+  // await prisma.userRole.deleteMany();
+  // await prisma.userRole.createMany({ data: userRoleData });
+  // await prisma.$executeRaw`ALTER SEQUENCE "UserRole_id_seq" RESTART WITH 1`;
+  // ----------------------------------------
+  // User
+  // ----------------------------------------
+  // await prisma.user.deleteMany();
+  // await prisma.user.createMany({ data: userData });
+  // ========================================
+  // Code for MySQL
+  // ----------------------------------------
+  // UserRole
+  // ----------------------------------------
+  // await prisma.userRole.deleteMany();
+  // await prisma.userRole.createMany({ data: userRoleData });
+  // await prisma.$executeRaw`ALTER TABLE UserRole AUTO_INCREMENT = 1`;
+  // ----------------------------------------
+  // User
+  // ----------------------------------------
+  // await prisma.user.deleteMany();
+  // await prisma.user.createMany({ data: userData });
+  // ========================================
+  // Code for SQLite
+  // ========================================
+  // UserRole
+  // ----------------------------------------
+  // await prisma.userRole.deleteMany();
+  // await prisma.userRole.createMany({ data: userRoleData });
+  // SQLite automatically handles ID incrementation and does not require manual sequence reset
+  // ----------------------------------------
+  // User
+  // ----------------------------------------
+  // await prisma.user.deleteMany();
+  // await prisma.user.createMany({ data: userData });
+  // ========================================
+// }
+
+// main()
+//   .catch((e) => {
+//     throw e;
+//   })
+//   .finally(async () => {
+//     await prisma.$disconnect();
+//   });

package/dist/settings/prisma-schema.json

@@ -0,0 +1,103 @@
+{
+  "datamodel": {
+    "enums": [],
+    "models": []
+  },
+  "schema": {
+    "inputObjectTypes": {},
+    "outputObjectTypes": {
+      "prisma": [
+        {
+          "name": "Query",
+          "fields": []
+        },
+        {
+          "name": "Mutation",
+          "fields": [
+            {
+              "name": "executeRaw",
+              "args": [
+                {
+                  "name": "query",
+                  "isRequired": true,
+                  "isNullable": false,
+                  "inputTypes": [
+                    {
+                      "type": "String",
+                      "location": "scalar",
+                      "isList": false
+                    }
+                  ]
+                },
+                {
+                  "name": "parameters",
+                  "isRequired": false,
+                  "isNullable": false,
+                  "inputTypes": [
+                    {
+                      "type": "Json",
+                      "location": "scalar",
+                      "isList": false
+                    }
+                  ]
+                }
+              ],
+              "isNullable": false,
+              "outputType": {
+                "type": "Json",
+                "location": "scalar",
+                "isList": false
+              }
+            },
+            {
+              "name": "queryRaw",
+              "args": [
+                {
+                  "name": "query",
+                  "isRequired": true,
+                  "isNullable": false,
+                  "inputTypes": [
+                    {
+                      "type": "String",
+                      "location": "scalar",
+                      "isList": false
+                    }
+                  ]
+                },
+                {
+                  "name": "parameters",
+                  "isRequired": false,
+                  "isNullable": false,
+                  "inputTypes": [
+                    {
+                      "type": "Json",
+                      "location": "scalar",
+                      "isList": false
+                    }
+                  ]
+                }
+              ],
+              "isNullable": false,
+              "outputType": {
+                "type": "Json",
+                "location": "scalar",
+                "isList": false
+              }
+            }
+          ]
+        }
+      ]
+    },
+    "enumTypes": {}
+  },
+  "mappings": {
+    "modelOperations": [],
+    "otherOperations": {
+      "read": [],
+      "write": [
+        "executeRaw",
+        "queryRaw"
+      ]
+    }
+  }
+}

package/dist/settings/prisma-sdk.ts

@@ -0,0 +1,30 @@
+import { resolve } from "path";
+import { readFileSync, writeFileSync } from "fs";
+import psdk from "@prisma/internals";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const { getDMMF } = psdk;
+const schemaPath: string = resolve(__dirname, "../prisma/schema.prisma");
+const prismaSchemaJsonPath: string = resolve(__dirname, "prisma-schema.json");
+
+export const prismaSdk = async (): Promise<void> => {
+  try {
+    const schema = readFileSync(schemaPath, "utf-8");
+
+    // Parse the schema into DMMF (Data Model Meta Format) and then convert to JSON
+    const dmmf = await getDMMF({ datamodel: schema });
+
+    // Write the DMMF schema to JSON
+    writeFileSync(prismaSchemaJsonPath, JSON.stringify(dmmf, null, 2));
+    console.log("Schema converted to JSON!");
+  } catch (error) {
+    console.error("Error parsing schema:", error);
+  }
+};
+
+if (process.argv[1] && process.argv[1].endsWith("prisma-sdk.ts")) {
+  prismaSdk();
+}