core-nails 1.0.2 → 1.0.4

package/dist/cli/generate/model.js

@@ -13,10 +13,11 @@ export async function generateModel(modelName) {
     // Pluralize collection name
     const collectionName = pluralize(modelName.charAt(0).toLowerCase() + modelName.slice(1));
     // Boilerplate content for model
-    const modelContent = `import CreateService from "../concerns/CreateService";
+    const modelContent = `import FirebaseAdmin from "@lib/FirebaseAdmin";
+import Nails from "core-nails";
 import { ${modelName}Schema } from "@schema";
 
-const ${modelName} = CreateService({
+const ${modelName} = Nails.InitializeModel({
   collection: "${collectionName}",
   schema: ${modelName}Schema,
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "core-nails",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "scripts": {
     "build": "tsc"
   },

package/src/cli/generate/model.ts

@@ -19,10 +19,11 @@ export async function generateModel(modelName: string) {
   );
 
   // Boilerplate content for model
-  const modelContent = `import CreateService from "../concerns/CreateService";
+  const modelContent = `import FirebaseAdmin from "@lib/FirebaseAdmin";
+import Nails from "core-nails";
 import { ${modelName}Schema } from "@schema";
 
-const ${modelName} = CreateService({
+const ${modelName} = Nails.InitializeModel({
   collection: "${collectionName}",
   schema: ${modelName}Schema,
 });

package/dist/src/cli/generate/index.d.ts

@@ -1 +0,0 @@
-export declare function runGenerate(args: string[]): Promise<void>;

package/dist/src/cli/generate/index.js

@@ -1,23 +0,0 @@
-export async function runGenerate(args) {
-    const [type, name] = args;
-    if (!type || !name) {
-        console.error("Usage: nails generate <type> <name>");
-        process.exit(1);
-    }
-    switch (type) {
-        case "model": {
-            const { generateModel } = await import("./model.js");
-            await generateModel(name);
-            break;
-        }
-        case "scaffold": {
-            const { generateScaffold } = await import("./scaffold.js");
-            await generateScaffold(name);
-            break;
-        }
-        default: {
-            console.error(`Unknown generator: ${type}`);
-            process.exit(1);
-        }
-    }
-}

package/dist/src/cli/generate/model.d.ts

@@ -1 +0,0 @@
-export declare function generateModel(modelName: string): Promise<void>;

package/dist/src/cli/generate/model.js

@@ -1,61 +0,0 @@
-import fs from "fs";
-import path from "path";
-import pluralize from "pluralize";
-export async function generateModel(modelName) {
-    if (!modelName) {
-        console.error("Usage: yarn generate model <ModelName>");
-        console.error("Example: yarn generate model UserActivity");
-        process.exit(1);
-    }
-    // Convert model name to match filename conventions
-    const dirName = path.join("app", "(model)", modelName);
-    const filePath = path.join(dirName, "index.ts");
-    // Pluralize collection name
-    const collectionName = pluralize(modelName.charAt(0).toLowerCase() + modelName.slice(1));
-    // Boilerplate content for model
-    const modelContent = `import CreateService from "../concerns/CreateService";
-import { ${modelName}Schema } from "@schema";
-
-const ${modelName} = CreateService({
-  collection: "${collectionName}",
-  schema: ${modelName}Schema,
-});
-
-export default ${modelName};
-`;
-    // Create model directory and write index.ts
-    fs.mkdirSync(dirName, { recursive: true });
-    fs.writeFileSync(filePath, modelContent);
-    console.log(`create  ${path.relative(process.cwd(), filePath)}`);
-    // --- Append schema stub to db/schema.ts ---
-    const dbDir = path.join("db");
-    fs.mkdirSync(dbDir, { recursive: true });
-    const schemaFilePath = path.join(dbDir, "schema.ts");
-    const schemaBaseContent = `import FirebaseAdmin from "@lib/FirebaseAdmin";
-import { z } from "zod";
-
-// Helper Function
-const FirebaseTimestamp = z.union([
-  z.instanceof(FirebaseAdmin.firestore.Timestamp),
-  z.date(),
-  z.custom((val) => val === FirebaseAdmin.firestore.FieldValue.serverTimestamp(), { message: "Expected serverTimestamp()" }),
-]);
-`;
-    // Ensure schema file exists
-    if (!fs.existsSync(schemaFilePath)) {
-        fs.writeFileSync(schemaFilePath, schemaBaseContent);
-        console.log(`create  ${path.relative(process.cwd(), schemaFilePath)}`);
-    }
-    else {
-        console.log(`append  ${path.relative(process.cwd(), schemaFilePath)}`);
-    }
-    const schemaStub = `
-// ${modelName} Schema
-export const ${modelName}Schema = z.object({
-  createdAt: FirebaseTimestamp.optional(),
-  updatedAt: FirebaseTimestamp.optional(),
-});
-export type ${modelName}Type = z.infer<typeof ${modelName}Schema>;
-`;
-    fs.appendFileSync(schemaFilePath, schemaStub);
-}

package/dist/src/cli/generate/scaffold.d.ts

@@ -1 +0,0 @@
-export declare function generateScaffold(scaffoldName: string): Promise<void>;

package/dist/src/cli/generate/scaffold.js

@@ -1,105 +0,0 @@
-import fs from "fs";
-import path from "path";
-import pluralize from "pluralize";
-import { generateModel } from "./model.js";
-export async function generateScaffold(scaffoldName) {
-    if (!scaffoldName) {
-        console.error("Usage: yarn generate scaffold <ScaffoldName>");
-        console.error("Example: yarn generate scaffold UserActivity");
-        process.exit(1);
-    }
-    function toSnakeCase(name) {
-        const snake = name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
-        return pluralize(snake);
-    }
-    const camelName = scaffoldName.charAt(0).toUpperCase() + scaffoldName.slice(1);
-    const snakePluralName = toSnakeCase(scaffoldName);
-    // --- 1️⃣ Generate Model (if missing) ---
-    const modelDir = path.join("app", "(model)", camelName);
-    if (!fs.existsSync(modelDir)) {
-        console.log(`Model not found for ${camelName}, generating...`);
-        await generateModel(scaffoldName);
-    }
-    // --- 2️⃣ Paths ---
-    const controllerDir = path.join("app", "(controller)", camelName);
-    const apiDir = path.join("app", "api", snakePluralName);
-    const apiIdDir = path.join(apiDir, "[id]");
-    // --- 3️⃣ Action files ---
-    const actions = ["index", "show", "create", "update", "destroy"];
-    fs.mkdirSync(controllerDir, { recursive: true });
-    const actionsDir = path.join(controllerDir, "actions");
-    fs.mkdirSync(actionsDir, { recursive: true });
-    actions.forEach((action) => {
-        const filePath = path.join(actionsDir, `${action}_action.ts`);
-        const content = `export default async function ${action}_action(req: Request${["index", "create"].includes(action) ? "" : ", id: string"}) {
-  return new Response(JSON.stringify({ message: "${action} ${camelName}" }));
-}
-`;
-        fs.writeFileSync(filePath, content);
-        console.log(`create  ${path.relative(process.cwd(), filePath)}`);
-    });
-    // --- 4️⃣ controller index.ts ---
-    const indexContent = actions
-        .map((action) => `import ${action}_action from "./actions/${action}_action";`)
-        .join("\n") +
-        `
-
-export default {
-${actions.map((a) => `  ${a}_action,`).join("\n")}
-};
-`;
-    const controllerIndexPath = path.join(controllerDir, "index.ts");
-    fs.writeFileSync(controllerIndexPath, indexContent);
-    console.log(`create  ${path.relative(process.cwd(), controllerIndexPath)}`);
-    // --- 5️⃣ API route.ts ---
-    fs.mkdirSync(apiDir, { recursive: true });
-    const apiRoutePath = path.join(apiDir, "route.ts");
-    const apiRouteContent = `/**
- * Standard RESTful Routes
- *
- * | HTTP Verb | Controller#Action | Purpose          | Path                                       |
- * |-----------|-------------------|------------------|--------------------------------------------|
- * | GET       | index             | List all         | /${snakePluralName}
- * | GET       | show              | Get one          | /${snakePluralName}/:id
- * | POST      | create            | Create           | /${snakePluralName}
- * | PATCH     | update            | Update (partial) | /${snakePluralName}/:id
- * | PUT       | update            | Update (full)    | /${snakePluralName}/:id
- * | DELETE    | destroy           | Delete           | /${snakePluralName}/:id
- */
-
-import ${camelName}Controller from "@controller/${camelName}";
-
-export async function GET(req: Request) {
-  return ${camelName}Controller.index_action(req);
-}
-
-export async function POST(req: Request) {
-  return ${camelName}Controller.create_action(req);
-}
-`;
-    fs.writeFileSync(apiRoutePath, apiRouteContent);
-    console.log(`create  ${path.relative(process.cwd(), apiRoutePath)}`);
-    // --- 6️⃣ API [id]/route.ts ---
-    fs.mkdirSync(apiIdDir, { recursive: true });
-    const apiIdRoutePath = path.join(apiIdDir, "route.ts");
-    const apiIdRouteContent = `import ${camelName}Controller from "@controller/${camelName}";
-
-export async function GET(req: Request, { params }: { params: { id: string } }) {
-  return ${camelName}Controller.show_action(req, params.id);
-}
-
-export async function PATCH(req: Request, { params }: { params: { id: string } }) {
-  return ${camelName}Controller.update_action(req, params.id);
-}
-
-export async function PUT(req: Request, { params }: { params: { id: string } }) {
-  return ${camelName}Controller.update_action(req, params.id);
-}
-
-export async function DELETE(req: Request, { params }: { params: { id: string } }) {
-  return ${camelName}Controller.destroy_action(req, params.id);
-}
-`;
-    fs.writeFileSync(apiIdRoutePath, apiIdRouteContent);
-    console.log(`create  ${path.relative(process.cwd(), apiIdRoutePath)}`);
-}

package/dist/src/cli/index.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-declare const command: any, args: any;
-declare function run(): Promise<void>;

package/dist/src/cli/index.js

@@ -1,18 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-const [, , command, ...args] = process.argv;
-async function run() {
-    switch (command) {
-        case "generate": {
-            const { runGenerate } = await import("./generate/index.js");
-            await runGenerate(args);
-            break;
-        }
-        default: {
-            console.log(`Unknown command: ${command}`);
-            console.log("Available commands: generate");
-            process.exit(1);
-        }
-    }
-}
-run();