@appweaver/core 1.1.6 → 1.2.0

package/server/swagger.js

@@ -11,7 +11,7 @@ const context_1 = require("../context");
 exports.default = (0, fastify_plugin_1.default)((server) => {
     server.register(swagger_1.default, {
         hideUntagged: common_1.config.SWAGGER_HIDE_UNTAGGED,
-        transformObject: (document) => addConfig(pruneUnusedSchemas(document)),
+        transformObject: (document) => addConfig(normalizeUnionTypes(pruneUnusedSchemas(document))),
         openapi: {
             info: {
                 title: common_1.config.APP_NAME,
@@ -64,21 +64,22 @@ exports.default = (0, fastify_plugin_1.default)((server) => {
         });
     }
 });
-function pruneUnusedSchemas(document) {
-    const schemas = document.openapiObject.components?.schemas ?? {};
-    const used = new Set();
+/**
+ * Rewrites the JSON Schema type lists of the document into the equivalent
+ * `anyOf` unions. The query filter schemas declare their plain values as a
+ * type list, so the request validator leaves the matching values untouched
+ * instead of coercing them into the first branch of a typed union, but a type
+ * list is only valid from OpenAPI 3.1 onwards, while the emitted document is
+ * an OpenAPI 3.0 one.
+ *
+ * @param {Object} document The OpenAPI document to rewrite in place.
+ * @returns {Object} The same document with every type list replaced by an
+ * `anyOf` union of the single-type schemas it listed.
+ */
+function normalizeUnionTypes(document) {
     const visit = (node) => {
-        if (!node || typeof node !== 'object')
+        if (!node || typeof node !== 'object') {
             return;
-        if (typeof node.$ref === 'string') {
-            const match = node.$ref.match(/^#\/components\/schemas\/(.+)$/);
-            if (match) {
-                const schemaName = match[1];
-                if (!used.has(schemaName)) {
-                    used.add(schemaName);
-                    visit(schemas[schemaName]);
-                }
-            }
         }
         if (Array.isArray(node)) {
             for (const item of node)
@@ -88,15 +89,31 @@ function pruneUnusedSchemas(document) {
         for (const value of Object.values(node)) {
             visit(value);
         }
+        if (Array.isArray(node.type)) {
+            const branches = node.type.map((type) => ({ type }));
+            delete node.type;
+            // A node carrying both keywords keeps its own union as one branch, so
+            // the two constraints still have to be satisfied together
+            node.anyOf = node.anyOf ? [{ anyOf: node.anyOf }, ...branches] : branches;
+        }
     };
-    visit(document.openapiObject.paths);
-    if (document.openapiObject.components?.schemas) {
-        document.openapiObject.components.schemas = Object.fromEntries(Object.entries(document.openapiObject.components.schemas)
-            .sort(([nameA, objA], [nameB, objB]) => String(objA.title ?? nameA).localeCompare(String(objB.title ?? nameB)))
-            .filter(([name]) => used.has(name)));
-    }
-    return document.openapiObject;
+    visit(document.paths);
+    visit(document.components?.schemas);
+    return document;
 }
+/**
+ * Adds the `x-{CONFIG_NAME}-config` extension to the document, describing where
+ * the routes of the application are mounted. The generated client reads it to
+ * classify the paths of the specification into their route groups, which the
+ * paths alone do not reveal once the prefixes are configurable. It holds the
+ * base path of every resource route keyed by its model name, together with the
+ * configured prefixes of the api, static, health, auth, account, and file
+ * routes. Every path is normalized to start with a slash and to end without
+ * one.
+ *
+ * @param {Object} document The OpenAPI document to extend in place.
+ * @returns {Object} The same document, carrying the configuration extension.
+ */
 function addConfig(document) {
     const normalizePath = (path) => {
         const withLeadingSlash = path.startsWith('/') ? path : `/${path}`;
@@ -120,3 +137,52 @@ function addConfig(document) {
     };
     return document;
 }
+/**
+ * Removes the schemas no route refers to from the document and sorts the ones
+ * that remain by name. Every model registered on the server is added to the
+ * schema registry, including the variants no route uses, so the document is
+ * pruned down to the schemas actually reachable from a path. The reachable set
+ * is collected by walking the paths for `#/components/schemas/` references and
+ * following each one into the schema it points at, so the schemas referenced
+ * only by another schema (i.e. a nested relation model, or a query filter
+ * referring to itself) are kept as well.
+ *
+ * @param {Object} document The transform argument of the Swagger plugin,
+ * wrapping the OpenAPI document in its `openapiObject` property.
+ * @returns {Object} The unwrapped OpenAPI document, with the unreferenced
+ * schemas removed and the remaining ones ordered by their title, falling back
+ * to the name they are registered under.
+ */
+function pruneUnusedSchemas(document) {
+    const schemas = document.openapiObject.components?.schemas ?? {};
+    const used = new Set();
+    const visit = (node) => {
+        if (!node || typeof node !== 'object')
+            return;
+        if (typeof node.$ref === 'string') {
+            const match = node.$ref.match(/^#\/components\/schemas\/(.+)$/);
+            if (match) {
+                const schemaName = match[1];
+                if (!used.has(schemaName)) {
+                    used.add(schemaName);
+                    visit(schemas[schemaName]);
+                }
+            }
+        }
+        if (Array.isArray(node)) {
+            for (const item of node)
+                visit(item);
+            return;
+        }
+        for (const value of Object.values(node)) {
+            visit(value);
+        }
+    };
+    visit(document.openapiObject.paths);
+    if (document.openapiObject.components?.schemas) {
+        document.openapiObject.components.schemas = Object.fromEntries(Object.entries(document.openapiObject.components.schemas)
+            .sort(([nameA, objA], [nameB, objB]) => String(objA.title ?? nameA).localeCompare(String(objB.title ?? nameB)))
+            .filter(([name]) => used.has(name)));
+    }
+    return document.openapiObject;
+}

package/server/virtual-projection.js

@@ -47,7 +47,7 @@ function buildVirtualProjectionPlan(responseSchemas, getSchema) {
 function createVirtualProjectionHook(plan) {
     return async (_request, reply, payload) => {
         const entries = plan[String(reply.statusCode)] ?? plan['2xx'];
-        if (!entries?.length || (!(0, common_1.isObject)(payload) && !(0, common_1.isArray)(payload))) {
+        if (!entries?.length || (!(0, common_1.isPlainObject)(payload) && !(0, common_1.isArray)(payload))) {
             return payload;
         }
         try {
@@ -77,7 +77,7 @@ function createVirtualProjectionHook(plan) {
  * @return {void}
  */
 function collectProjectionEntries(schema, path, entries, getSchema, visitedRefs) {
-    if (!(0, common_1.isObject)(schema)) {
+    if (!(0, common_1.isPlainObject)(schema)) {
         return;
     }
     if ((0, common_1.isString)(schema['$ref'])) {
@@ -97,7 +97,7 @@ function collectProjectionEntries(schema, path, entries, getSchema, visitedRefs)
         return;
     }
     // OpenAPI-style response objects wrap the schema in media type content
-    if ((0, common_1.isObject)(schema['content'])) {
+    if ((0, common_1.isPlainObject)(schema['content'])) {
         for (const media of Object.values(schema['content'])) {
             collectProjectionEntries(media?.schema, path, entries, getSchema, visitedRefs);
         }
@@ -110,10 +110,10 @@ function collectProjectionEntries(schema, path, entries, getSchema, visitedRefs)
             }
         }
     }
-    if ((0, common_1.isObject)(schema['items'])) {
+    if ((0, common_1.isPlainObject)(schema['items'])) {
         collectProjectionEntries(schema['items'], [...path, ARRAY_SEGMENT], entries, getSchema, visitedRefs);
     }
-    if ((0, common_1.isObject)(schema['properties'])) {
+    if ((0, common_1.isPlainObject)(schema['properties'])) {
         for (const [key, property] of Object.entries(schema['properties'])) {
             collectProjectionEntries(property, [...path, key], entries, getSchema, visitedRefs);
         }
@@ -213,9 +213,11 @@ function applyProjection(value, path, index, resourceName) {
     }
     if (index === path.length) {
         if ((0, common_1.isArray)(value)) {
-            return value.map((item) => (0, common_1.isObject)(item) ? (0, utils_1.projectVirtualFields)(item, resourceName) : item);
+            return value.map((item) => (0, common_1.isPlainObject)(item) ? (0, utils_1.projectVirtualFields)(item, resourceName) : item);
         }
-        return (0, common_1.isObject)(value) ? (0, utils_1.projectVirtualFields)(value, resourceName) : value;
+        return (0, common_1.isPlainObject)(value)
+            ? (0, utils_1.projectVirtualFields)(value, resourceName)
+            : value;
     }
     const segment = path[index];
     if (segment === ARRAY_SEGMENT) {
@@ -223,7 +225,7 @@ function applyProjection(value, path, index, resourceName) {
             ? value.map((item) => applyProjection(item, path, index + 1, resourceName))
             : value;
     }
-    if (!(0, common_1.isObject)(value) || value[segment] === undefined) {
+    if (!(0, common_1.isPlainObject)(value) || value[segment] === undefined) {
         return value;
     }
     value[segment] = applyProjection(value[segment], path, index + 1, resourceName);

package/types/generated.d.ts

@@ -1,3 +1,4 @@
+import { AggregateSelect, QueryFilter, QuerySort } from '@appweaver/common';
 export type ApiKey = {
     id: number;
     key: string;
@@ -43,6 +44,28 @@ export type ApiKeyUpdate = {
     description?: string | null;
     enabled?: boolean;
 };
+export type ApiKeyRelationCreate = {
+    name?: string | null;
+    description?: string | null;
+    enabled?: boolean;
+    expiresAt?: Date | null;
+};
+export type ApiKeyRelationUpdate = {
+    id: number;
+    name?: string | null;
+    description?: string | null;
+    enabled?: boolean;
+};
+export type ApiKeyRelationInput = {
+    id?: number;
+    name?: string | null;
+    description?: string | null;
+    enabled?: boolean;
+    expiresAt?: Date | null;
+};
+export type ApiKeyQuery = QueryFilter<ApiKey>;
+export type ApiKeySort = QuerySort<ApiKeyMultiple>;
+export type ApiKeyAggregate = AggregateSelect<ApiKey>;
 export type OneTimeToken = {
     id: number;
     tokenHash: string;
@@ -82,6 +105,29 @@ export type OneTimeTokenUpdate = {
     expiresAt?: Date;
     data?: any;
 };
+export type OneTimeTokenRelationCreate = {
+    tokenHash: string;
+    purpose: string;
+    expiresAt: Date;
+    data: any;
+};
+export type OneTimeTokenRelationUpdate = {
+    id: number;
+    tokenHash?: string;
+    purpose?: string;
+    expiresAt?: Date;
+    data?: any;
+};
+export type OneTimeTokenRelationInput = {
+    id?: number;
+    tokenHash?: string;
+    purpose?: string;
+    expiresAt?: Date;
+    data?: any;
+};
+export type OneTimeTokenQuery = QueryFilter<OneTimeToken>;
+export type OneTimeTokenSort = QuerySort<OneTimeTokenMultiple>;
+export type OneTimeTokenAggregate = AggregateSelect<OneTimeToken>;
 export type Permission = {
     id: number;
     name: string;
@@ -103,6 +149,20 @@ export type PermissionCreate = {
 export type PermissionUpdate = {
     name?: string;
 };
+export type PermissionRelationCreate = {
+    name: string;
+};
+export type PermissionRelationUpdate = {
+    id: number;
+    name?: string;
+};
+export type PermissionRelationInput = {
+    id?: number;
+    name?: string;
+};
+export type PermissionQuery = QueryFilter<Permission>;
+export type PermissionSort = QuerySort<PermissionMultiple>;
+export type PermissionAggregate = AggregateSelect<Permission>;
 export type Role = {
     id: number;
     name: string;
@@ -114,25 +174,39 @@ export type Role = {
 export type RoleSingle = {
     id: number;
     name: string;
-    permissions: Array<PermissionSingle>;
+    permissions?: Array<PermissionSingle>;
 };
 export type RoleMultiple = {
     id: number;
     name: string;
-    permissions: Array<PermissionSingle>;
+    permissions?: Array<PermissionSingle>;
 };
 export type RoleCreate = {
     name: string;
     permissions: Array<{
         id: number;
-    }> | Array<number>;
+    } | number>;
 };
 export type RoleUpdate = {
     name?: string;
     permissions?: Array<{
         id: number;
-    }> | Array<number>;
+    } | number>;
+};
+export type RoleRelationCreate = {
+    name: string;
+};
+export type RoleRelationUpdate = {
+    id: number;
+    name?: string;
 };
+export type RoleRelationInput = {
+    id?: number;
+    name?: string;
+};
+export type RoleQuery = QueryFilter<Role>;
+export type RoleSort = QuerySort<RoleMultiple>;
+export type RoleAggregate = AggregateSelect<Role>;
 export type File = {
     id: number;
     name: string;
@@ -196,3 +270,35 @@ export type FileUpdate = {
     title?: string | null;
     description?: string | null;
 };
+export type FileRelationCreate = {
+    name: string;
+    originalName: string;
+    mimeType: string;
+    sizeBytes: number;
+    checksum: string;
+    title?: string | null;
+    description?: string | null;
+};
+export type FileRelationUpdate = {
+    id: number;
+    name?: string;
+    originalName?: string;
+    mimeType?: string;
+    sizeBytes?: number;
+    checksum?: string;
+    title?: string | null;
+    description?: string | null;
+};
+export type FileRelationInput = {
+    id?: number;
+    name?: string;
+    originalName?: string;
+    mimeType?: string;
+    sizeBytes?: number;
+    checksum?: string;
+    title?: string | null;
+    description?: string | null;
+};
+export type FileQuery = QueryFilter<File>;
+export type FileSort = QuerySort<FileMultiple>;
+export type FileAggregate = AggregateSelect<File>;

package/utils/schema-util.js

@@ -25,7 +25,7 @@ function createSchemaModel(schema, config = {}) {
         schema.title ??
         `Object${existingModels.length}`;
     const reference = typebox_1.Type.Ref(name);
-    if (existingModels.find((m) => m.name === name) &&
+    if (existingModels.find((m) => m.value?.name === name) &&
         config.skipExisting !== false) {
         return reference;
     }

package/utils/virtual-util.js

@@ -40,7 +40,7 @@ function projectVirtualFields(resource, resourceName) {
         const value = projectedVirtual[key];
         const relationSchema = (0, common_1.extractSchemaProperties)(relationsModel, key);
         const fileSchema = (0, common_1.extractSchemaProperties)(filesModel, key);
-        if ((0, common_1.isObject)(value) || ((0, common_1.isArray)(value) && (0, common_1.isObject)(value[0]))) {
+        if ((0, common_1.isPlainObject)(value) || ((0, common_1.isArray)(value) && (0, common_1.isPlainObject)(value[0]))) {
             const nestedResourceName = (0, common_1.extractResourceName)(relationSchema ?? fileSchema);
             if (nestedResourceName) {
                 projectedVirtual[key] = (0, common_1.isArray)(value)