@bg-dev/nuxt-zenstack 0.0.2 → 0.0.4

package/dist/runtime/composables/useZenstackReadMany/where.js

@@ -0,0 +1,235 @@
+export function matchesWhere(item, where) {
+  if (!where) return true;
+  if (!item) return false;
+  const itemRecord = item;
+  const whereRecord = where;
+  for (const key of Object.keys(whereRecord)) {
+    if (whereRecord[key] === void 0) continue;
+    const filter = whereRecord[key];
+    if (key === "AND") {
+      if (Array.isArray(filter)) {
+        if (!filter.every((cond) => matchesWhere(item, cond))) return false;
+      } else {
+        if (!matchesWhere(item, filter)) return false;
+      }
+      continue;
+    }
+    if (key === "OR") {
+      if (Array.isArray(filter)) {
+        if (!filter.some((cond) => matchesWhere(item, cond))) return false;
+      } else {
+        if (!matchesWhere(item, filter)) return false;
+      }
+      continue;
+    }
+    if (key === "NOT") {
+      if (Array.isArray(filter)) {
+        if (filter.some((cond) => matchesWhere(item, cond))) return false;
+      } else {
+        if (matchesWhere(item, filter)) return false;
+      }
+      continue;
+    }
+    const value = itemRecord[key];
+    if (!checkCondition(value, filter)) {
+      return false;
+    }
+  }
+  return true;
+}
+function checkCondition(value, filter) {
+  if (filter === null) {
+    return value === null;
+  }
+  if (filter === void 0) {
+    return true;
+  }
+  if (typeof filter !== "object" && typeof filter !== "function") {
+    if (value instanceof Date && typeof filter === "string") {
+      return value.toISOString() === filter;
+    }
+    return value === filter;
+  }
+  if (value instanceof Date && filter instanceof Date) {
+    return value.getTime() === filter.getTime();
+  }
+  const filterRecord = filter;
+  const keys = Object.keys(filterRecord);
+  if (keys.length === 0) return true;
+  let caseInsensitive = false;
+  if (filterRecord.mode === "insensitive") {
+    caseInsensitive = true;
+  }
+  for (const op of keys) {
+    if (op === "mode") continue;
+    let expected = filterRecord[op];
+    let actual = value;
+    if (["lt", "lte", "gt", "gte", "equals", "not"].includes(op)) {
+      if (actual instanceof Date && typeof expected === "string") {
+        const d = new Date(expected);
+        if (!Number.isNaN(d.getTime())) expected = d;
+      }
+    }
+    if (caseInsensitive && typeof actual === "string" && typeof expected === "string") {
+      if (["equals", "not", "contains", "startsWith", "endsWith"].includes(op)) {
+        actual = actual.toLowerCase();
+        expected = expected.toLowerCase();
+      }
+    }
+    switch (op) {
+      case "equals":
+        if (actual instanceof Date && expected instanceof Date) {
+          if (actual.getTime() !== expected.getTime()) return false;
+        } else if (actual !== expected) {
+          return false;
+        }
+        break;
+      case "not":
+        if (typeof expected === "object" && expected !== null && !Array.isArray(expected) && !(expected instanceof Date)) {
+          if (checkCondition(value, expected)) return false;
+        } else {
+          if (actual instanceof Date && expected instanceof Date) {
+            if (actual.getTime() === expected.getTime()) return false;
+          } else if (actual === expected) {
+            return false;
+          }
+        }
+        break;
+      case "in":
+        if (!Array.isArray(expected)) return false;
+        if (caseInsensitive && typeof actual === "string") {
+          const lowerVal = actual.toLowerCase();
+          const lowerList = expected.map((e) => typeof e === "string" ? e.toLowerCase() : e);
+          if (!lowerList.includes(lowerVal)) return false;
+        } else {
+          if (actual instanceof Date) {
+            const time = actual.getTime();
+            if (!expected.some((e) => e instanceof Date && e.getTime() === time || e === actual)) return false;
+          } else {
+            if (!expected.includes(actual)) return false;
+          }
+        }
+        break;
+      case "notIn":
+        if (!Array.isArray(expected)) return false;
+        if (caseInsensitive && typeof actual === "string") {
+          const lowerVal = actual.toLowerCase();
+          const lowerList = expected.map((e) => typeof e === "string" ? e.toLowerCase() : e);
+          if (lowerList.includes(lowerVal)) return false;
+        } else {
+          if (actual instanceof Date) {
+            const time = actual.getTime();
+            if (expected.some((e) => e instanceof Date && e.getTime() === time || e === actual)) return false;
+          } else {
+            if (expected.includes(actual)) return false;
+          }
+        }
+        break;
+      case "lt":
+        if (typeof actual === "number" && typeof expected === "number") {
+          if (!(actual < expected)) return false;
+        } else if (actual instanceof Date && expected instanceof Date) {
+          if (!(actual < expected)) return false;
+        } else if (typeof actual === "string" && typeof expected === "string") {
+          if (!(actual < expected)) return false;
+        } else {
+          if (!(actual < expected)) return false;
+        }
+        break;
+      case "lte":
+        if (!(actual <= expected)) return false;
+        break;
+      case "gt":
+        if (!(actual > expected)) return false;
+        break;
+      case "gte":
+        if (!(actual >= expected)) return false;
+        break;
+      case "contains":
+        if (typeof actual !== "string" || typeof expected !== "string" || !actual.includes(expected)) return false;
+        break;
+      case "startsWith":
+        if (typeof actual !== "string" || typeof expected !== "string" || !actual.startsWith(expected)) return false;
+        break;
+      case "endsWith":
+        if (typeof actual !== "string" || typeof expected !== "string" || !actual.endsWith(expected)) return false;
+        break;
+      // Relations
+      case "some":
+        if (!Array.isArray(value)) return false;
+        if (!value.some((v) => checkInternal(v, expected))) return false;
+        break;
+      case "every":
+        if (!Array.isArray(value)) return false;
+        if (!value.every((v) => checkInternal(v, expected))) return false;
+        break;
+      case "none":
+        if (!Array.isArray(value)) return false;
+        if (value.some((v) => checkInternal(v, expected))) return false;
+        break;
+      case "is":
+        if (expected === null) {
+          if (value != null) return false;
+        } else {
+          if (value == null) return false;
+          if (!checkInternal(value, expected)) return false;
+        }
+        break;
+      case "isNot":
+        if (expected === null) {
+          if (value == null) return false;
+        } else {
+          if (value == null) break;
+          if (checkInternal(value, expected)) return false;
+        }
+        break;
+      default:
+        if (value && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date)) {
+          if (!checkCondition(value[op], expected)) return false;
+        } else {
+          return false;
+        }
+    }
+  }
+  return true;
+}
+function checkInternal(item, where) {
+  return matchesWhereInternal(item, where);
+}
+function matchesWhereInternal(item, where) {
+  if (!where) return true;
+  if (!item) return false;
+  for (const key of Object.keys(where)) {
+    if (where[key] === void 0) continue;
+    const filter = where[key];
+    if (key === "AND") {
+      if (Array.isArray(filter)) {
+        if (!filter.every((cond) => matchesWhereInternal(item, cond))) return false;
+      } else {
+        if (!matchesWhereInternal(item, filter)) return false;
+      }
+      continue;
+    }
+    if (key === "OR") {
+      if (Array.isArray(filter)) {
+        if (!filter.some((cond) => matchesWhereInternal(item, cond))) return false;
+      } else {
+        if (!matchesWhereInternal(item, filter)) return false;
+      }
+      continue;
+    }
+    if (key === "NOT") {
+      if (Array.isArray(filter)) {
+        if (filter.some((cond) => matchesWhereInternal(item, cond))) return false;
+      } else {
+        if (matchesWhereInternal(item, filter)) return false;
+      }
+      continue;
+    }
+    const value = item[key];
+    if (!checkCondition(value, filter)) {
+      return false;
+    }
+  }
+  return true;
+}

package/dist/runtime/composables/useZenstackStore/helpers.js

@@ -3,10 +3,10 @@ export function getModelDef(model) {
   return zenstackSchema.models[model];
 }
 export function isIdString(model) {
-  const def = getModelDef(model);
-  if (!def.uniqueFields.id)
-    throw new Error(`No id field for model ${model.toString()}`);
-  return def.uniqueFields.id.type === "String";
+  const modelDef = getModelDef(model);
+  if (!modelDef.uniqueFields.id)
+    throw new Error(`Model ${model.toString()} does not have an id as a unique field`);
+  return modelDef.uniqueFields.id.type === "String";
 }
 export function getModels() {
   return Object.keys(zenstackSchema.models);

package/dist/runtime/composables/useZenstackStore/index.d.ts

@@ -1,18 +1,50 @@
 import type { $Zmodel, $Zid } from '#build/types/nuxt-zenstack';
+type FetchEntry = {
+    model: string;
+    method: 'GET' | 'PATCH' | 'POST' | 'DELETE';
+    ssr: boolean;
+    timestamp: number;
+    id?: string | number;
+    query?: string;
+    body?: string;
+};
 export declare function useZenstackStore(): {
     state: Readonly<import("vue").Ref<{
         readonly [x: string]: {
-            readonly [x: string]: object;
+            readonly [x: string]: {
+                readonly [x: string]: string | number | boolean | readonly string[] | null;
+            };
         };
     }, {
         readonly [x: string]: {
-            readonly [x: string]: object;
+            readonly [x: string]: {
+                readonly [x: string]: string | number | boolean | readonly string[] | null;
+            };
         };
     }>>;
+    fetchHistory: Readonly<import("vue").Ref<readonly {
+        readonly model: string;
+        readonly method: "GET" | "PATCH" | "POST" | "DELETE";
+        readonly ssr: boolean;
+        readonly timestamp: number;
+        readonly id?: string | number | undefined;
+        readonly query?: string | undefined;
+        readonly body?: string | undefined;
+    }[], readonly {
+        readonly model: string;
+        readonly method: "GET" | "PATCH" | "POST" | "DELETE";
+        readonly ssr: boolean;
+        readonly timestamp: number;
+        readonly id?: string | number | undefined;
+        readonly query?: string | undefined;
+        readonly body?: string | undefined;
+    }[]>>;
     setOne: (model: $Zmodel, input: object) => void;
     setMany: (model: $Zmodel, input: object[]) => void;
     getOne: <Zmodel extends $Zmodel>(model: Zmodel, input: $Zid<Zmodel>) => any;
     getMany: (model: $Zmodel) => any;
     deleteOne: <Model extends $Zmodel>(model: Model, id: $Zid<Model>) => void;
     deleteMany: (model: $Zmodel) => void;
+    addToFetchHistory: (entry: Omit<FetchEntry, "ssr" | "timestamp">) => void;
 };
+export {};

package/dist/runtime/composables/useZenstackStore/index.js

@@ -1,19 +1,19 @@
-import { generateNormalizrSchema, getNormalizrSchema } from "./normalization.js";
+import { generateNormalizrSchema, getNormalizrSchema, mergeNormalizedData } from "./normalization.js";
 import { normalize, denormalize } from "normalizr";
-import { defu } from "defu";
 import { readonly, useState } from "#imports";
 generateNormalizrSchema();
 export function useZenstackStore() {
-  const state = useState("zenstack-store", () => ({}));
+  const state = useState("zenstack-state", () => ({}));
+  const fetchHistory = useState("zenstack-fetch-history", () => []);
   function setOne(model, input) {
     const schema = getNormalizrSchema(model);
     const res = normalize(input, schema);
-    state.value = defu(res.entities, state.value);
+    state.value = mergeNormalizedData(res.entities, state.value);
   }
   function setMany(model, input) {
     const schema = [getNormalizrSchema(model)];
     const res = normalize(input, schema);
-    state.value = defu(res.entities, state.value);
+    state.value = mergeNormalizedData(res.entities, state.value);
   }
   function getOne(model, input) {
     const schema = getNormalizrSchema(model);
@@ -45,5 +45,26 @@ export function useZenstackStore() {
     }
     state.value = newState;
   }
-  return { state: readonly(state), setOne, setMany, getOne, getMany, deleteOne, deleteMany };
+  function addToFetchHistory(entry) {
+    fetchHistory.value.push({
+      method: entry.method,
+      model: entry.model,
+      body: entry.body,
+      id: entry.id,
+      query: entry.query,
+      ssr: typeof window === "undefined",
+      timestamp: (/* @__PURE__ */ new Date()).getTime()
+    });
+  }
+  return {
+    state: readonly(state),
+    fetchHistory: readonly(fetchHistory),
+    setOne,
+    setMany,
+    getOne,
+    getMany,
+    deleteOne,
+    deleteMany,
+    addToFetchHistory
+  };
 }

package/dist/runtime/composables/useZenstackStore/normalization.d.ts

@@ -1,5 +1,18 @@
 import { schema as normalizrSchema } from 'normalizr';
 import type { $Zmodel } from '#build/types/nuxt-zenstack';
-declare function getNormalizrSchema(model: $Zmodel): normalizrSchema.Entity<any>;
-declare function generateNormalizrSchema(): void;
-export { getNormalizrSchema, generateNormalizrSchema };
+type NormalizedDataField = number | string | boolean | null | string[];
+/**
+ * Normalized data structure
+ * {
+ *   model: {
+ *     id: {
+ *       field: NormalizedDataField
+ *     }
+ *   }
+ * }
+ */
+export type NormalizedData = Record<string, Record<string, Record<string, NormalizedDataField>>>;
+export declare function getNormalizrSchema(model: $Zmodel): normalizrSchema.Entity<any>;
+export declare function generateNormalizrSchema(): void;
+export declare function mergeNormalizedData(newData: NormalizedData, currentData: NormalizedData): NormalizedData;
+export {};

package/dist/runtime/composables/useZenstackStore/normalization.js

@@ -1,13 +1,14 @@
 import { schema as normalizrSchema } from "normalizr";
 import { getModelDef, getModels, isValidModel } from "./helpers.js";
+import { defu } from "defu";
 const NORMALIZR_SCHEMA = /* @__PURE__ */ new Map();
-function getNormalizrSchema(model) {
+export function getNormalizrSchema(model) {
   const schema = NORMALIZR_SCHEMA.get(model);
   if (!schema)
     throw new Error(`Model ${model.toString()} not defined`);
   return schema;
 }
-function generateNormalizrSchema() {
+export function generateNormalizrSchema() {
   const models = getModels();
   for (const model of models) {
     NORMALIZR_SCHEMA.set(model, new normalizrSchema.Entity(model.toString()));
@@ -28,4 +29,16 @@ function generateNormalizrSchema() {
     }
   }
 }
-export { getNormalizrSchema, generateNormalizrSchema };
+export function mergeNormalizedData(newData, currentData) {
+  const merged = defu(newData, currentData);
+  for (const model in merged) {
+    for (const id in merged[model]) {
+      for (const field in merged[model][id]) {
+        if (Array.isArray(merged[model][id][field])) {
+          merged[model][id][field] = Array.from(new Set(merged[model][id][field]));
+        }
+      }
+    }
+  }
+  return merged;
+}

package/dist/runtime/composables/useZenstackUpdate/index.d.ts

@@ -1,9 +1,9 @@
-import type { $Zmodel, $Zitem, $ZupdateData, $Zid } from '#build/types/nuxt-zenstack';
+import type { $Zmodel, $Zitem, $ZupdateData, $Zid, $Zerror } from '#build/types/nuxt-zenstack';
 import type { Status } from '../common.js';
 import type { Ref } from '#imports';
 export declare function useZenstackUpdate<Zmodel extends $Zmodel, Zitem extends $Zitem<Zmodel>>(model: Zmodel): {
     data: Ref<Zitem | null>;
-    error: Ref<Error | null>;
+    error: Ref<$Zerror | null>;
     status: Ref<Status>;
     mutate: (id: $Zid<Zmodel>, input: $ZupdateData<Zmodel>) => Promise<void>;
     reset: () => void;

package/dist/runtime/composables/useZenstackUpdate/index.js

@@ -1,7 +1,7 @@
 import { ref } from "#imports";
 import { joinURL } from "ufo";
 import { useZenstackStore } from "../useZenstackStore/index.js";
-import { getConfig } from "../common.js";
+import { getConfig, getFetch } from "../common.js";
 export function useZenstackUpdate(model) {
   const data = ref(null);
   const error = ref(null);
@@ -14,17 +14,19 @@ export function useZenstackUpdate(model) {
     status.value = "idle";
   }
   async function mutate(id, input) {
+    const _fetch = getFetch();
     const url = joinURL(config.apiPath, `/models/${model.toString()}/${id}`);
+    const body = { data: input };
+    const method = "PATCH";
+    store.addToFetchHistory({
+      model: model.toString(),
+      method,
+      body: JSON.stringify(body)
+    });
     reset();
     status.value = "pending";
     try {
-      const res = await $fetch(url, {
-        method: "PATCH",
-        body: {
-          data: input
-          // TODO: maybe include relations
-        }
-      });
+      const res = await _fetch(url, { method, body });
       if (res.data)
         store.setOne(model, res.data);
       data.value = res.data;

package/dist/runtime/server/api/models/[model]/[id].delete.js

@@ -1,14 +1,17 @@
 import { defineEventHandler } from "h3";
 import { parseModel, parseId } from "../../../utils/parsers.js";
 import { getModelOperations } from "../../../utils/index.js";
+import { createError } from "../../../utils/error.js";
 export default defineEventHandler(async (event) => {
   const model = parseModel(event);
   const id = parseId(event, model);
-  const operations = getModelOperations(model);
+  const operations = getModelOperations(event, model);
   const data = await operations.delete({
     where: {
       id
     }
+  }).catch((err) => {
+    throw createError(err);
   });
   return { data };
 });

package/dist/runtime/server/api/models/[model]/[id].get.js

@@ -1,16 +1,19 @@
 import { parseModel, parseId, parseReadArgs } from "../../../utils/parsers.js";
 import { defineEventHandler } from "h3";
 import { getModelOperations } from "../../../utils/index.js";
+import { createError } from "../../../utils/error.js";
 export default defineEventHandler(async (event) => {
   const model = parseModel(event);
   const id = parseId(event, model);
   const readArgs = parseReadArgs(event, model);
-  const operations = getModelOperations(model);
+  const operations = getModelOperations(event, model);
   const data = await operations.findUnique({
     include: readArgs.include,
     where: {
       id
     }
+  }).catch((err) => {
+    throw createError(err);
   });
   return { data };
 });

package/dist/runtime/server/api/models/[model]/[id].patch.js

@@ -1,16 +1,21 @@
-import { parseModel, parseId, parseUpdateData } from "../../../utils/parsers.js";
+import { parseModel, parseId, parseUpdateArgs } from "../../../utils/parsers.js";
 import { defineEventHandler } from "h3";
-import { getModelOperations } from "../../../utils/index.js";
+import { getModelOperations, includeAll } from "../../../utils/index.js";
+import { createError } from "../../../utils/error.js";
 export default defineEventHandler(async (event) => {
   const model = parseModel(event);
   const id = parseId(event, model);
-  const updateData = await parseUpdateData(event, model);
-  const operations = getModelOperations(model);
+  const updateArgs = await parseUpdateArgs(event, model);
+  const operations = getModelOperations(event, model);
+  const include = includeAll(model);
   const data = await operations.update({
-    data: updateData.data,
+    data: updateArgs.data,
+    include,
     where: {
       id
     }
+  }).catch((err) => {
+    throw createError(err);
   });
   return { data };
 });

package/dist/runtime/server/api/models/[model]/index.get.js

@@ -1,16 +1,19 @@
 import { parseModel, parseReadArgs } from "../../../utils/parsers.js";
 import { defineEventHandler } from "h3";
 import { getModelOperations } from "../../../utils/index.js";
+import { createError } from "../../../utils/error.js";
 export default defineEventHandler(async (event) => {
   const model = parseModel(event);
   const readArgs = parseReadArgs(event, model);
-  const operations = getModelOperations(model);
+  const operations = getModelOperations(event, model);
   const data = await operations.findMany({
     orderBy: readArgs.orderBy,
     include: readArgs.include,
     skip: readArgs.skip,
     take: readArgs.take,
     where: readArgs.where
+  }).catch((err) => {
+    throw createError(err);
   });
   return { data };
 });

package/dist/runtime/server/api/models/[model]/index.post.js

@@ -1,12 +1,17 @@
-import { parseModel, parseCreateData } from "../../../utils/parsers.js";
+import { parseModel, parseCreateArgs } from "../../../utils/parsers.js";
 import { defineEventHandler } from "h3";
-import { getModelOperations } from "../../../utils/index.js";
+import { getModelOperations, includeAll } from "../../../utils/index.js";
+import { createError } from "../../../utils/error.js";
 export default defineEventHandler(async (event) => {
   const model = parseModel(event);
-  const createData = await parseCreateData(event, model);
-  const operations = getModelOperations(model);
+  const createArgs = await parseCreateArgs(event, model);
+  const operations = getModelOperations(event, model);
+  const include = includeAll(model);
   const data = await operations.create({
-    data: createData.data
+    data: createArgs.data,
+    include
+  }).catch((err) => {
+    throw createError(err);
   });
   return { data };
 });

package/dist/runtime/server/utils/error.d.ts

@@ -0,0 +1,9 @@
+import type { $ZormError } from '#build/types/nuxt-zenstack';
+import { ORMErrorReason } from '@zenstackhq/orm';
+export declare function createError(ormError: $ZormError): import("h3").H3Error<{
+    ormErrorReason: ORMErrorReason;
+    dbErrorCode?: unknown;
+    dbErrorMessage?: string;
+    model?: string;
+    rejectedByPolicyReason?: import("@zenstackhq/orm").RejectedByPolicyReason;
+}>;

package/dist/runtime/server/utils/error.js

@@ -0,0 +1,49 @@
+import { ORMErrorReason } from "@zenstackhq/orm";
+import { createError as createH3Error } from "h3";
+export function createError(ormError) {
+  let statusCode = 500;
+  switch (ormError.reason) {
+    case ORMErrorReason.CONFIG_ERROR:
+      statusCode = 500;
+      break;
+    case ORMErrorReason.DB_QUERY_ERROR:
+      statusCode = 409;
+      break;
+    case ORMErrorReason.INTERNAL_ERROR:
+      statusCode = 500;
+      break;
+    case ORMErrorReason.NOT_FOUND:
+      statusCode = 404;
+      break;
+    case ORMErrorReason.INVALID_INPUT:
+      statusCode = 400;
+      break;
+    case ORMErrorReason.NOT_SUPPORTED:
+      statusCode = 501;
+      break;
+    case ORMErrorReason.REJECTED_BY_POLICY:
+      statusCode = 401;
+      break;
+    default:
+      statusCode = 500;
+  }
+  const error = {
+    name: "Zenstack Error",
+    cause: ormError.cause,
+    message: ormError.message,
+    statusCode,
+    statusMessage: ormError.reason,
+    stack: ormError.stack,
+    fatal: false,
+    unhandled: false,
+    toJSON: () => error,
+    data: {
+      ormErrorReason: ormError.reason,
+      dbErrorCode: ormError.dbErrorCode,
+      dbErrorMessage: ormError.dbErrorMessage,
+      model: ormError.model,
+      rejectedByPolicyReason: ormError.rejectedByPolicyReason
+    }
+  };
+  return createH3Error(error);
+}

package/dist/runtime/server/utils/index.d.ts

@@ -1,11 +1,8 @@
-import type { ClientContract } from '@zenstackhq/orm';
-import type { $Zschema, $Zmodel, $Zoperations } from '#build/types/nuxt-zenstack';
-declare let _client: ClientContract<$Zschema> | null;
-export declare function provideClient(client: typeof _client): void;
-export declare function getClient(): ClientContract<SchemaType>;
-export declare function getModelOperations<Zmodel extends $Zmodel>(model: Zmodel): $Zoperations<Zmodel>;
-export declare function getModelDef(model: $Zmodel): any;
+import type { $Zmodel, $Zoperations, $Zdef } from '#build/types/nuxt-zenstack';
+import type { H3Event } from 'h3';
+export declare function getModelOperations<Zmodel extends $Zmodel>(event: H3Event, model: Zmodel): $Zoperations<Zmodel>;
+export declare function getModelDef(model: $Zmodel): $Zdef;
 export declare function isIdString(model: $Zmodel): boolean;
 export declare function getModels(): $Zmodel[];
 export declare function isValidModel(model: $Zmodel): boolean;
-export {};
+export declare function includeAll<Zmodel extends $Zmodel>(model: Zmodel): boolean | import("@zenstackhq/orm").SelectIncludeOmit<SchemaType, any, boolean, true>;