core-nails 1.0.1 → 1.0.2

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.2",
   "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/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 };