tauri-plugin-mongoose 0.1.0 → 0.2.0

package/dist/index.d.mts

@@ -1,3 +1,62 @@
-declare function connect(url: string): Promise<void>;
+declare class Time {
+    hours: number;
+    minutes: number;
+    seconds: number;
+    milliseconds: number;
+    constructor(hours: number, minutes: number, seconds: number, milliseconds: number);
+    toString(_12_hour?: boolean, format?: {
+        hours?: string;
+        minutes?: string;
+        seconds?: string;
+        milliseconds?: string;
+    }): string;
+    static fromString(timeString: string): Time;
+    getTime(): Date;
+    static fromDate(date: Date): Time;
+}
 
-export { connect };
+type SchemaTypes = 'string' | 'number' | 'boolean' | 'object' | 'array' | 'date' | 'time';
+interface SchemaItem {
+    type: SchemaTypes;
+    default?: Function;
+    required?: boolean;
+    unique?: boolean;
+    ref?: string;
+}
+interface Schema {
+    [key: string]: SchemaItem;
+}
+type TypeMap = {
+    string: string;
+    number: number;
+    boolean: boolean;
+    date: Date;
+    time: Time;
+    object: object;
+    array: any[];
+    buffer: Uint8Array;
+    mixed: any;
+};
+type InferSchemaType<T extends Schema> = {
+    [K in keyof T]?: T[K]['required'] extends true ? TypeMap[T[K]['type']] : TypeMap[T[K]['type']] | undefined;
+} & {
+    [K in keyof T as T[K]['required'] extends true ? K : never]-?: TypeMap[T[K]['type']];
+};
+
+declare class Model {
+    name: string;
+    schema: Schema;
+    constructor(name: string, schema: Schema);
+    getById(id: string): Promise<InferSchemaType<typeof this.schema>>;
+    validate(doc: InferSchemaType<typeof this.schema>): Promise<InferSchemaType<Schema>>;
+    create(doc: InferSchemaType<typeof this.schema>): Promise<InferSchemaType<typeof this.schema>>;
+}
+
+interface ConnectOptions {
+    url: string;
+    dbName?: string;
+}
+declare function connect(options: ConnectOptions): Promise<void>;
+declare function connect(url: string, dbName?: string): Promise<void>;
+
+export { type ConnectOptions, type InferSchemaType, Model, type Schema, type SchemaItem, type SchemaTypes, type TypeMap, connect };

package/dist/index.d.ts

@@ -1,3 +1,62 @@
-declare function connect(url: string): Promise<void>;
+declare class Time {
+    hours: number;
+    minutes: number;
+    seconds: number;
+    milliseconds: number;
+    constructor(hours: number, minutes: number, seconds: number, milliseconds: number);
+    toString(_12_hour?: boolean, format?: {
+        hours?: string;
+        minutes?: string;
+        seconds?: string;
+        milliseconds?: string;
+    }): string;
+    static fromString(timeString: string): Time;
+    getTime(): Date;
+    static fromDate(date: Date): Time;
+}
 
-export { connect };
+type SchemaTypes = 'string' | 'number' | 'boolean' | 'object' | 'array' | 'date' | 'time';
+interface SchemaItem {
+    type: SchemaTypes;
+    default?: Function;
+    required?: boolean;
+    unique?: boolean;
+    ref?: string;
+}
+interface Schema {
+    [key: string]: SchemaItem;
+}
+type TypeMap = {
+    string: string;
+    number: number;
+    boolean: boolean;
+    date: Date;
+    time: Time;
+    object: object;
+    array: any[];
+    buffer: Uint8Array;
+    mixed: any;
+};
+type InferSchemaType<T extends Schema> = {
+    [K in keyof T]?: T[K]['required'] extends true ? TypeMap[T[K]['type']] : TypeMap[T[K]['type']] | undefined;
+} & {
+    [K in keyof T as T[K]['required'] extends true ? K : never]-?: TypeMap[T[K]['type']];
+};
+
+declare class Model {
+    name: string;
+    schema: Schema;
+    constructor(name: string, schema: Schema);
+    getById(id: string): Promise<InferSchemaType<typeof this.schema>>;
+    validate(doc: InferSchemaType<typeof this.schema>): Promise<InferSchemaType<Schema>>;
+    create(doc: InferSchemaType<typeof this.schema>): Promise<InferSchemaType<typeof this.schema>>;
+}
+
+interface ConnectOptions {
+    url: string;
+    dbName?: string;
+}
+declare function connect(options: ConnectOptions): Promise<void>;
+declare function connect(url: string, dbName?: string): Promise<void>;
+
+export { type ConnectOptions, type InferSchemaType, Model, type Schema, type SchemaItem, type SchemaTypes, type TypeMap, connect };

package/dist/index.js

@@ -20,16 +20,137 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // index.ts
 var index_exports = {};
 __export(index_exports, {
+  Model: () => Model,
   connect: () => connect
 });
 module.exports = __toCommonJS(index_exports);
+var import_core2 = require("@tauri-apps/api/core");
+
+// model/index.ts
 var import_core = require("@tauri-apps/api/core");
-async function connect(url) {
-  await (0, import_core.invoke)("plugin:mongoose|connect", {
-    url
-  });
+
+// types/time.type.ts
+var isTime = (obj) => {
+  return obj && typeof obj.hours === "number" && typeof obj.minutes === "number" && typeof obj.seconds === "number" && typeof obj.milliseconds === "number";
+};
+var Time = class _Time {
+  constructor(hours, minutes, seconds, milliseconds) {
+    this.hours = hours;
+    this.minutes = minutes;
+    this.seconds = seconds;
+    this.milliseconds = milliseconds;
+  }
+  toString(_12_hour = false, format = { hours: "2-digit", minutes: "2-digit" }) {
+    const pad = (num, size = 2) => num.toString().padStart(size, "0");
+    let h = this.hours;
+    let am_pm = "";
+    if (_12_hour) {
+      am_pm = h >= 12 ? " PM" : " AM";
+      h = h % 12 || 12;
+    }
+    let result = `${pad(h)}:${pad(this.minutes)}`;
+    if (format.seconds) {
+      result += `:${pad(this.seconds)}`;
+    }
+    if (format.milliseconds) {
+      result += `.${pad(this.milliseconds, 3)}`;
+    }
+    return result + am_pm;
+  }
+  static fromString(timeString) {
+    const [time, am_pm] = timeString.split(" ");
+    const [hours, minutes, seconds] = time.split(":").map(Number);
+    const milliseconds = 0;
+    return new _Time(hours, minutes, seconds, milliseconds);
+  }
+  getTime() {
+    return new Date(0, 0, 0, this.hours, this.minutes, this.seconds, this.milliseconds);
+  }
+  static fromDate(date) {
+    return new _Time(date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());
+  }
+};
+
+// model/index.ts
+var Model = class {
+  constructor(name, schema) {
+    this.name = name;
+    this.schema = schema;
+  }
+  async getById(id) {
+    const doc = await (0, import_core.invoke)("plugin:mongoose|get_by_id", {
+      collection: this.name,
+      id
+    });
+    return this.validate(doc);
+  }
+  async validate(doc) {
+    for (const key in this.schema) {
+      const schemaItem = this.schema[key];
+      const value = doc[key];
+      if (schemaItem.required && (value === void 0 || value === null || value === "")) {
+        throw new Error(`Property ${key} is required`);
+      }
+      if (value !== void 0 && value !== null) {
+        if (schemaItem.type === "string" && typeof value !== "string") {
+          throw new Error(`Property ${key} must be a string`);
+        }
+        if (schemaItem.type === "number" && typeof value !== "number") {
+          throw new Error(`Property ${key} must be a number`);
+        }
+        if (schemaItem.type === "boolean" && typeof value !== "boolean") {
+          throw new Error(`Property ${key} must be a boolean`);
+        }
+        if (schemaItem.type === "object" && typeof value !== "object") {
+          throw new Error(`Property ${key} must be an object`);
+        }
+        if (schemaItem.type === "array" && !Array.isArray(value)) {
+          throw new Error(`Property ${key} must be an array`);
+        }
+        if (schemaItem.type === "date" && !(value instanceof Date)) {
+          throw new Error(`Property ${key} must be a date`);
+        }
+        if (schemaItem.type === "time" && !(value instanceof Time)) {
+          throw new Error(`Property ${key} must be a time`);
+        }
+        if (schemaItem.type === "time" && !isTime(value)) {
+          throw new Error(`Property ${key} must be a time`);
+        }
+      }
+      if (schemaItem.default && value === void 0) {
+        doc[key] = schemaItem.default();
+      }
+      if (schemaItem.unique && value !== void 0 && value !== null) {
+        const existing = await (0, import_core.invoke)("plugin:mongoose|get_by_id", {
+          collection: this.name,
+          id: value
+        });
+        if (existing) {
+          throw new Error(`Property ${key} must be unique`);
+        }
+      }
+    }
+    return doc;
+  }
+  async create(doc) {
+    const validatedDoc = await this.validate(doc);
+    return await (0, import_core.invoke)("plugin:mongoose|create", {
+      collection: this.name,
+      document: validatedDoc
+    });
+  }
+};
+
+// index.ts
+async function connect(urlOrOptions, dbName) {
+  if (typeof urlOrOptions === "string") {
+    await (0, import_core2.invoke)("plugin:mongoose|connect", { url: urlOrOptions, dbName });
+  } else {
+    await (0, import_core2.invoke)("plugin:mongoose|connect", { url: urlOrOptions.url, dbName: urlOrOptions.dbName });
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  Model,
   connect
 });

package/dist/index.mjs

@@ -1,10 +1,130 @@
 // index.ts
+import { invoke as invoke2 } from "@tauri-apps/api/core";
+
+// model/index.ts
 import { invoke } from "@tauri-apps/api/core";
-async function connect(url) {
-  await invoke("plugin:mongoose|connect", {
-    url
-  });
+
+// types/time.type.ts
+var isTime = (obj) => {
+  return obj && typeof obj.hours === "number" && typeof obj.minutes === "number" && typeof obj.seconds === "number" && typeof obj.milliseconds === "number";
+};
+var Time = class _Time {
+  constructor(hours, minutes, seconds, milliseconds) {
+    this.hours = hours;
+    this.minutes = minutes;
+    this.seconds = seconds;
+    this.milliseconds = milliseconds;
+  }
+  toString(_12_hour = false, format = { hours: "2-digit", minutes: "2-digit" }) {
+    const pad = (num, size = 2) => num.toString().padStart(size, "0");
+    let h = this.hours;
+    let am_pm = "";
+    if (_12_hour) {
+      am_pm = h >= 12 ? " PM" : " AM";
+      h = h % 12 || 12;
+    }
+    let result = `${pad(h)}:${pad(this.minutes)}`;
+    if (format.seconds) {
+      result += `:${pad(this.seconds)}`;
+    }
+    if (format.milliseconds) {
+      result += `.${pad(this.milliseconds, 3)}`;
+    }
+    return result + am_pm;
+  }
+  static fromString(timeString) {
+    const [time, am_pm] = timeString.split(" ");
+    const [hours, minutes, seconds] = time.split(":").map(Number);
+    const milliseconds = 0;
+    return new _Time(hours, minutes, seconds, milliseconds);
+  }
+  getTime() {
+    return new Date(0, 0, 0, this.hours, this.minutes, this.seconds, this.milliseconds);
+  }
+  static fromDate(date) {
+    return new _Time(date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());
+  }
+};
+
+// model/index.ts
+var Model = class {
+  constructor(name, schema) {
+    this.name = name;
+    this.schema = schema;
+  }
+  async getById(id) {
+    const doc = await invoke("plugin:mongoose|get_by_id", {
+      collection: this.name,
+      id
+    });
+    return this.validate(doc);
+  }
+  async validate(doc) {
+    for (const key in this.schema) {
+      const schemaItem = this.schema[key];
+      const value = doc[key];
+      if (schemaItem.required && (value === void 0 || value === null || value === "")) {
+        throw new Error(`Property ${key} is required`);
+      }
+      if (value !== void 0 && value !== null) {
+        if (schemaItem.type === "string" && typeof value !== "string") {
+          throw new Error(`Property ${key} must be a string`);
+        }
+        if (schemaItem.type === "number" && typeof value !== "number") {
+          throw new Error(`Property ${key} must be a number`);
+        }
+        if (schemaItem.type === "boolean" && typeof value !== "boolean") {
+          throw new Error(`Property ${key} must be a boolean`);
+        }
+        if (schemaItem.type === "object" && typeof value !== "object") {
+          throw new Error(`Property ${key} must be an object`);
+        }
+        if (schemaItem.type === "array" && !Array.isArray(value)) {
+          throw new Error(`Property ${key} must be an array`);
+        }
+        if (schemaItem.type === "date" && !(value instanceof Date)) {
+          throw new Error(`Property ${key} must be a date`);
+        }
+        if (schemaItem.type === "time" && !(value instanceof Time)) {
+          throw new Error(`Property ${key} must be a time`);
+        }
+        if (schemaItem.type === "time" && !isTime(value)) {
+          throw new Error(`Property ${key} must be a time`);
+        }
+      }
+      if (schemaItem.default && value === void 0) {
+        doc[key] = schemaItem.default();
+      }
+      if (schemaItem.unique && value !== void 0 && value !== null) {
+        const existing = await invoke("plugin:mongoose|get_by_id", {
+          collection: this.name,
+          id: value
+        });
+        if (existing) {
+          throw new Error(`Property ${key} must be unique`);
+        }
+      }
+    }
+    return doc;
+  }
+  async create(doc) {
+    const validatedDoc = await this.validate(doc);
+    return await invoke("plugin:mongoose|create", {
+      collection: this.name,
+      document: validatedDoc
+    });
+  }
+};
+
+// index.ts
+async function connect(urlOrOptions, dbName) {
+  if (typeof urlOrOptions === "string") {
+    await invoke2("plugin:mongoose|connect", { url: urlOrOptions, dbName });
+  } else {
+    await invoke2("plugin:mongoose|connect", { url: urlOrOptions.url, dbName: urlOrOptions.dbName });
+  }
 }
 export {
+  Model,
   connect
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "tauri-plugin-mongoose",
-    "version": "0.1.0",
+    "version": "0.2.0",
     "description": "Tauri plugin for MongoDB/Mongoose-like database operations",
     "main": "dist/index.cjs",
     "module": "dist/index.js",