core-nails 1.0.10 → 1.0.13

package/.github/workflows/publish.yml

@@ -0,0 +1,32 @@
+name: Publish to npm
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - 'package.json'
+
+jobs:
+  build-and-publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: 20
+          registry-url: https://registry.npmjs.org/
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Build dist
+        run: npm run build
+
+      - name: Publish to npm
+        run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/dist/cli/generate/scaffold.js

@@ -82,22 +82,27 @@ export async function POST(req: Request) {
     // --- 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}";
+    const apiIdRouteContent = `import { NextRequest } from "next/server";
+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 GET(req: NextRequest, context: { params: Promise<{ id: string }> }): Promise<Response> {
+  const { id } = await context.params;
+  return ${camelName}Controller.show_action(req, id);
 }
 
-export async function PATCH(req: Request, { params }: { params: { id: string } }) {
-  return ${camelName}Controller.update_action(req, params.id);
+export async function PATCH(req: NextRequest, context: { params: Promise<{ id: string }> }): Promise<Response> {
+  const { id } = await context.params;
+  return ${camelName}Controller.update_action(req, id);
 }
 
-export async function PUT(req: Request, { params }: { params: { id: string } }) {
-  return ${camelName}Controller.update_action(req, params.id);
+export async function PUT(req: NextRequest, context: { params: Promise<{ id: string }> }): Promise<Response> {
+  const { id } = await context.params;
+  return ${camelName}Controller.update_action(req, id);
 }
 
-export async function DELETE(req: Request, { params }: { params: { id: string } }) {
-  return ${camelName}Controller.destroy_action(req, params.id);
+export async function DELETE(req: NextRequest, context: { params: Promise<{ id: string }> }): Promise<Response> {
+  const { id } = await context.params;
+  return ${camelName}Controller.destroy_action(req, id);
 }
 `;
     fs.writeFileSync(apiIdRoutePath, apiIdRouteContent);

package/dist/helpers/InitializeModel.d.ts

@@ -1,10 +1,5 @@
 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;
-};
+type WhereCondition<T> = Partial<Record<keyof T, any>>;
 declare function InitializeModel<TSchema extends ZodObject<ZodRawShape>>(opts: {
     collection: string;
     schema: TSchema;
@@ -21,10 +16,10 @@ declare function InitializeModel<TSchema extends ZodObject<ZodRawShape>>(opts: {
     }) | 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> & {
+    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> & {
+    find_by(conditions: WhereCondition<z.core.output<TSchema>>): Promise<(z.core.output<TSchema> & {
         id: string;
     }) | null>;
 };

package/dist/helpers/InitializeModel.js

@@ -74,16 +74,16 @@ function InitializeModel(opts) {
         },
         async where(conditions) {
             let query = collection;
-            for (const cond of conditions) {
-                query = query.where(cond.field, cond.operator, cond.value);
+            for (const [field, value] of Object.entries(conditions)) {
+                query = query.where(field, "==", 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);
+            for (const [field, value] of Object.entries(conditions)) {
+                query = query.where(field, "==", value);
             }
             const snapshot = await query.limit(1).get();
             if (snapshot.empty)

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "core-nails",
-  "version": "1.0.10",
+  "version": "1.0.13",
   "scripts": {
-    "build": "tsc"
+    "build": "tsc",
+    "bump": "npm version patch"
   },
   "bin": {
     "nails": "dist/cli/index.js"

package/src/cli/generate/scaffold.ts

@@ -110,22 +110,27 @@ export async function POST(req: Request) {
 
   const apiIdRoutePath = path.join(apiIdDir, "route.ts");
 
-  const apiIdRouteContent = `import ${camelName}Controller from "@controller/${camelName}";
+  const apiIdRouteContent = `import { NextRequest } from "next/server";
+import ${camelName}Controller from "@controller/${camelName}";
 
-export async function GET(req: Request, { params }: { params: { id: string } }) {
-  return ${camelName}Controller.show_action(req, (await params).id);
+export async function GET(req: NextRequest, context: { params: Promise<{ id: string }> }): Promise<Response> {
+  const { id } = await context.params;
+  return ${camelName}Controller.show_action(req, id);
 }
 
-export async function PATCH(req: Request, { params }: { params: { id: string } }) {
-  return ${camelName}Controller.update_action(req, (await params).id);
+export async function PATCH(req: NextRequest, context: { params: Promise<{ id: string }> }): Promise<Response> {
+  const { id } = await context.params;
+  return ${camelName}Controller.update_action(req, id);
 }
 
-export async function PUT(req: Request, { params }: { params: { id: string } }) {
-  return ${camelName}Controller.update_action(req, (await params).id);
+export async function PUT(req: NextRequest, context: { params: Promise<{ id: string }> }): Promise<Response> {
+  const { id } = await context.params;
+  return ${camelName}Controller.update_action(req, id);
 }
 
-export async function DELETE(req: Request, { params }: { params: { id: string } }) {
-  return ${camelName}Controller.destroy_action(req, (await params).id);
+export async function DELETE(req: NextRequest, context: { params: Promise<{ id: string }> }): Promise<Response> {
+  const { id } = await context.params;
+  return ${camelName}Controller.destroy_action(req, id);
 }
 `;
 

package/src/helpers/InitializeModel.ts

@@ -1,22 +1,6 @@
 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;
-};
+type WhereCondition<T> = Partial<Record<keyof T, any>>;
 
 function InitializeModel<TSchema extends ZodObject<ZodRawShape>>(opts: {
   collection: string;
@@ -119,34 +103,22 @@ function InitializeModel<TSchema extends ZodObject<ZodRawShape>>(opts: {
       await collection.doc(id).delete();
     },
 
-    async where(
-      conditions: WhereCondition<T>[]
-    ): Promise<WithId[]> {
+    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
-        );
+      for (const [field, value] of Object.entries(conditions)) {
+        query = query.where(field, "==", value);
       }
 
       const snapshot = await query.get();
       return parseDocs(snapshot);
     },
 
-    async find_by(
-      conditions: WhereCondition<T>[]
-    ): Promise<WithId | null> {
+    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
-        );
+      for (const [field, value] of Object.entries(conditions)) {
+        query = query.where(field, "==", value);
       }
 
       const snapshot = await query.limit(1).get();