core-nails 1.0.1 → 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/dist/helpers/InitializeModel.d.ts

@@ -0,0 +1,31 @@
+import { z, ZodObject, ZodRawShape } from "zod";
+type WhereOperator = "==" | "!=" | "<" | "<=" | ">" | ">=" | "array-contains" | "in" | "not-in" | "array-contains-any";
+type WhereCondition<T> = {
+    field: keyof T;
+    operator: WhereOperator;
+    value: any;
+};
+declare function InitializeModel<TSchema extends ZodObject<ZodRawShape>>(opts: {
+    collection: string;
+    schema: TSchema;
+    FirebaseAdmin: any;
+}): {
+    all(): Promise<(z.core.output<TSchema> & {
+        id: string;
+    })[]>;
+    find(id: string): Promise<(z.core.output<TSchema> & {
+        id: string;
+    }) | null>;
+    create(data: z.core.output<TSchema>, id?: string): Promise<(z.core.output<TSchema> & {
+        id: string;
+    }) | null>;
+    update(data: Partial<z.core.output<TSchema>>, id: string): Promise<void>;
+    destroy(id: string): Promise<void>;
+    where(conditions: WhereCondition<z.core.output<TSchema>>[]): Promise<(z.core.output<TSchema> & {
+        id: string;
+    })[]>;
+    find_by(conditions: WhereCondition<z.core.output<TSchema>>[]): Promise<(z.core.output<TSchema> & {
+        id: string;
+    }) | null>;
+};
+export default InitializeModel;

package/dist/helpers/InitializeModel.js

@@ -0,0 +1,95 @@
+function InitializeModel(opts) {
+    const { collection: collectionName, schema, FirebaseAdmin } = opts;
+    const db = FirebaseAdmin.firestore();
+    const collection = db.collection(collectionName);
+    function parseDoc(doc) {
+        if (!doc.exists)
+            return null;
+        const result = schema.safeParse(doc.data());
+        if (!result.success || typeof result.data !== "object" || result.data === null)
+            return null;
+        return {
+            id: doc.id,
+            ...result.data,
+        };
+    }
+    function parseDocs(snapshot) {
+        return snapshot.docs
+            .map(parseDoc)
+            .filter((doc) => doc !== null);
+    }
+    return {
+        async all() {
+            const snapshot = await collection.get();
+            return parseDocs(snapshot);
+        },
+        async find(id) {
+            const snapshot = await collection.doc(id).get();
+            return parseDoc(snapshot);
+        },
+        async create(data, id) {
+            const dataWithTimestamp = {
+                ...data,
+                createdAt: FirebaseAdmin.firestore.FieldValue.serverTimestamp(),
+                updatedAt: FirebaseAdmin.firestore.FieldValue.serverTimestamp(),
+            };
+            const parsed = schema.parse(dataWithTimestamp);
+            let docRef;
+            if (id) {
+                docRef = collection.doc(id);
+                const existingDoc = await docRef.get();
+                if (existingDoc.exists) {
+                    throw new Error(`Document with ID ${id} already exists!`);
+                }
+                await docRef.set(parsed);
+            }
+            else {
+                docRef = await collection.add(parsed);
+            }
+            const docSnap = await docRef.get();
+            if (!docSnap.exists)
+                return null;
+            const result = schema.safeParse(docSnap.data());
+            if (!result.success || typeof result.data !== "object" || result.data === null)
+                return null;
+            return {
+                id: docSnap.id,
+                ...result.data,
+            };
+        },
+        async update(data, id) {
+            if ("createdAt" in data) {
+                throw new Error("Cannot modify createdAt field");
+            }
+            const dataWithTimestamp = {
+                ...data,
+                updatedAt: FirebaseAdmin.firestore.FieldValue.serverTimestamp(),
+            };
+            const partialSchema = schema.partial();
+            const parsed = partialSchema.parse(dataWithTimestamp);
+            await collection.doc(id).update(parsed);
+        },
+        async destroy(id) {
+            await collection.doc(id).delete();
+        },
+        async where(conditions) {
+            let query = collection;
+            for (const cond of conditions) {
+                query = query.where(cond.field, cond.operator, cond.value);
+            }
+            const snapshot = await query.get();
+            return parseDocs(snapshot);
+        },
+        async find_by(conditions) {
+            let query = collection;
+            for (const cond of conditions) {
+                query = query.where(cond.field, cond.operator, cond.value);
+            }
+            const snapshot = await query.limit(1).get();
+            if (snapshot.empty)
+                return null;
+            return parseDoc(snapshot.docs[0]);
+        },
+    };
+}
+export default InitializeModel;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import InitializeModel from "./helpers/InitializeModel.js";
+declare const _default: {
+    InitializeModel: typeof InitializeModel;
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,2 @@
+import InitializeModel from "./helpers/InitializeModel.js";
+export default { InitializeModel };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "core-nails",
-  "version": "1.0.1",
+  "version": "1.0.4",
   "scripts": {
     "build": "tsc"
   },
@@ -13,6 +13,10 @@
     "typescript": "^6.0.2"
   },
   "dependencies": {
-    "pluralize": "^8.0.0"
+    "pluralize": "^8.0.0",
+    "zod": "^4.3.6"
+  },
+  "exports": {
+    ".": "./dist/index.js"
   }
 }

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/src/helpers/InitializeModel.ts

@@ -0,0 +1,161 @@
+import { z, ZodObject, ZodRawShape } from "zod";
+
+type WhereOperator =
+  | "=="
+  | "!="
+  | "<"
+  | "<="
+  | ">"
+  | ">="
+  | "array-contains"
+  | "in"
+  | "not-in"
+  | "array-contains-any";
+
+type WhereCondition<T> = {
+  field: keyof T;
+  operator: WhereOperator;
+  value: any;
+};
+
+function InitializeModel<TSchema extends ZodObject<ZodRawShape>>(opts: {
+  collection: string;
+  schema: TSchema;
+  FirebaseAdmin: any;
+}) {
+  const { collection: collectionName, schema, FirebaseAdmin } = opts;
+
+  type T = z.infer<TSchema>;
+  type WithId = T & { id: string };
+
+  const db = FirebaseAdmin.firestore();
+  const collection = db.collection(collectionName);
+
+  function parseDoc(doc: any): WithId | null {
+    if (!doc.exists) return null;
+
+    const result = schema.safeParse(doc.data());
+
+    if (!result.success || typeof result.data !== "object" || result.data === null) return null;
+
+    return {
+      id: doc.id,
+      ...result.data,
+    };
+  }
+
+  function parseDocs(
+    snapshot: any
+  ): WithId[] {
+    return snapshot.docs
+      .map(parseDoc)
+      .filter((doc: WithId | null): doc is WithId => doc !== null);
+  }
+
+  return {
+    async all(): Promise<WithId[]> {
+      const snapshot = await collection.get();
+      return parseDocs(snapshot);
+    },
+
+    async find(id: string): Promise<WithId | null> {
+      const snapshot = await collection.doc(id).get();
+      return parseDoc(snapshot);
+    },
+
+    async create(data: T, id?: string): Promise<WithId | null> {
+      const dataWithTimestamp = {
+        ...data,
+        createdAt: FirebaseAdmin.firestore.FieldValue.serverTimestamp(),
+        updatedAt: FirebaseAdmin.firestore.FieldValue.serverTimestamp(),
+      };
+
+      const parsed = schema.parse(dataWithTimestamp) as any;
+
+      let docRef: any;
+
+      if (id) {
+        docRef = collection.doc(id);
+
+        const existingDoc = await docRef.get();
+        if (existingDoc.exists) {
+          throw new Error(`Document with ID ${id} already exists!`);
+        }
+
+        await docRef.set(parsed);
+      } else {
+        docRef = await collection.add(parsed);
+      }
+
+      const docSnap = await docRef.get();
+      if (!docSnap.exists) return null;
+
+      const result = schema.safeParse(docSnap.data());
+      if (!result.success || typeof result.data !== "object" || result.data === null) return null;
+
+      return {
+        id: docSnap.id,
+        ...result.data,
+      };
+    },
+
+    async update(data: Partial<T>, id: string): Promise<void> {
+      if ("createdAt" in data) {
+        throw new Error("Cannot modify createdAt field");
+      }
+
+      const dataWithTimestamp = {
+        ...data,
+        updatedAt: FirebaseAdmin.firestore.FieldValue.serverTimestamp(),
+      };
+
+      const partialSchema = schema.partial();
+      const parsed = partialSchema.parse(dataWithTimestamp);
+
+      await collection.doc(id).update(parsed);
+    },
+
+    async destroy(id: string): Promise<void> {
+      await collection.doc(id).delete();
+    },
+
+    async where(
+      conditions: WhereCondition<T>[]
+    ): Promise<WithId[]> {
+      let query: any = collection;
+
+      for (const cond of conditions) {
+        query = query.where(
+          cond.field as string,
+          cond.operator,
+          cond.value
+        );
+      }
+
+      const snapshot = await query.get();
+      return parseDocs(snapshot);
+    },
+
+    async find_by(
+      conditions: WhereCondition<T>[]
+    ): Promise<WithId | null> {
+      let query: any = collection;
+
+      for (const cond of conditions) {
+        query = query.where(
+          cond.field as string,
+          cond.operator,
+          cond.value
+        );
+      }
+
+      const snapshot = await query.limit(1).get();
+
+      if (snapshot.empty) return null;
+
+      return parseDoc(snapshot.docs[0]);
+    },
+  };
+}
+
+export default InitializeModel;

package/src/index.ts

@@ -0,0 +1,3 @@
+import InitializeModel from "./helpers/InitializeModel.js";
+
+export default { InitializeModel };

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();