@tachybase/plugin-devtools 0.23.8

package/dist/server/swagger/collections/paths/associations/single-association.js

@@ -0,0 +1,105 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var single_association_exports = {};
+__export(single_association_exports, {
+  default: () => single_association_default
+});
+module.exports = __toCommonJS(single_association_exports);
+var import_collection = require("../collection");
+var import_multiple_association = require("./multiple-association");
+function removeFilterByTkParams(apiDoc) {
+  for (const action of Object.values(apiDoc)) {
+    if (action.parameters) {
+      action.parameters = action.parameters.filter((param) => {
+        if (param.$ref) {
+          return param.$ref !== "#/components/parameters/filterByTk";
+        }
+      });
+    }
+  }
+  return apiDoc;
+}
+const parametersShouldRemove = [
+  "#/components/parameters/filterByTk",
+  "#/components/parameters/filter",
+  "#/components/parameters/sort"
+];
+function filterSingleAssociationParams(apiDoc) {
+  for (const action of Object.values(apiDoc)) {
+    if (action.parameters) {
+      action.parameters = action.parameters.filter((param) => {
+        if (param.$ref) {
+          return !parametersShouldRemove.includes(param.$ref);
+        }
+      });
+    }
+  }
+  return apiDoc;
+}
+var single_association_default = (collection, relationField) => {
+  const options = {
+    collection,
+    relationField
+  };
+  return {
+    [`/${collection.name}/{collectionIndex}/${relationField.name}:get`]: removeFilterByTkParams(
+      filterSingleAssociationParams((0, import_multiple_association.appendCollectionIndexParams)((0, import_collection.GetActionTemplate)(options)))
+    ),
+    [`/${collection.name}/{collectionIndex}/${relationField.name}:set`]: (0, import_multiple_association.appendCollectionIndexParams)({
+      post: {
+        tags: [`${collection.name}.${relationField.name}`],
+        summary: "Associate a record",
+        parameters: [
+          {
+            name: "tk",
+            in: "query",
+            description: "targetKey",
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "OK"
+          }
+        }
+      }
+    }),
+    [`/${collection.name}/{collectionIndex}/${relationField.name}:remove`]: (0, import_multiple_association.appendCollectionIndexParams)({
+      post: {
+        tags: [`${collection.name}.${relationField.name}`],
+        summary: "Disassociate the relationship record",
+        responses: {
+          "200": {
+            description: "OK"
+          }
+        }
+      }
+    }),
+    [`/${collection.name}/{collectionIndex}/${relationField.name}:update`]: removeFilterByTkParams(
+      filterSingleAssociationParams((0, import_multiple_association.appendCollectionIndexParams)((0, import_collection.UpdateActionTemplate)(options)))
+    ),
+    [`/${collection.name}/{collectionIndex}/${relationField.name}:create`]: removeFilterByTkParams(
+      filterSingleAssociationParams((0, import_multiple_association.appendCollectionIndexParams)((0, import_collection.CreateActionTemplate)(options)))
+    ),
+    [`/${collection.name}/{collectionIndex}/${relationField.name}:destroy`]: removeFilterByTkParams(
+      filterSingleAssociationParams((0, import_multiple_association.appendCollectionIndexParams)((0, import_collection.DestroyActionTemplate)(options)))
+    )
+  };
+};

package/dist/server/swagger/collections/paths/collection.d.ts

@@ -0,0 +1,201 @@
+import { Collection, RelationField } from '@tachybase/database';
+type TemplateOptions = {
+    collection: Collection;
+    relationField?: RelationField;
+};
+export declare function relationTypeToString(field: RelationField): any;
+export declare function ListActionTemplate({ collection, relationField }: TemplateOptions): {
+    get: {
+        tags: string[];
+        summary: string;
+        parameters: ({
+            name: string;
+            in: string;
+            description: string;
+            required: boolean;
+            schema: {
+                type: string;
+            };
+            $ref?: undefined;
+        } | {
+            $ref: string;
+            name?: undefined;
+            in?: undefined;
+            description?: undefined;
+            required?: undefined;
+            schema?: undefined;
+        })[];
+        responses: {
+            '200': {
+                description: string;
+                content: {
+                    'application/json': {
+                        schema: {
+                            type: string;
+                            properties: {
+                                data: {
+                                    type: string;
+                                    items: {
+                                        $ref: string;
+                                    };
+                                };
+                                meta: {
+                                    type: string;
+                                    properties: {
+                                        count: {
+                                            type: string;
+                                            description: string;
+                                        };
+                                        page: {
+                                            type: string;
+                                            description: string;
+                                        };
+                                        pageSize: {
+                                            type: string;
+                                            description: string;
+                                        };
+                                        totalPage: {
+                                            type: string;
+                                            description: string;
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+export declare function GetActionTemplate(options: TemplateOptions): {
+    get: {
+        tags: string[];
+        summary: string;
+        parameters: {
+            $ref: string;
+        }[];
+        responses: {
+            '200': {
+                description: string;
+                content: {
+                    'application/json': {
+                        schema: {
+                            type: string;
+                            properties: {
+                                data: {
+                                    $ref: string;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+export declare function CreateActionTemplate(options: TemplateOptions): {
+    post: {
+        tags: string[];
+        summary: string;
+        parameters: {
+            $ref: string;
+        }[];
+        requestBody: {
+            content: {
+                'application/json': {
+                    schema: {
+                        $ref: string;
+                    };
+                };
+            };
+        };
+        responses: {
+            '200': {
+                description: string;
+                content: {
+                    'application/json': {
+                        schema: {
+                            type: string;
+                            properties: {
+                                data: {
+                                    $ref: string;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+export declare function UpdateActionTemplate(options: TemplateOptions): {
+    post: {
+        tags: string[];
+        summary: string;
+        parameters: {
+            $ref: string;
+        }[];
+        requestBody: {
+            content: {
+                'application/json': {
+                    schema: {
+                        $ref: string;
+                    };
+                };
+            };
+        };
+        responses: {
+            '200': {
+                description: string;
+                content: {
+                    'application/json': {
+                        schema: {
+                            type: string;
+                            properties: {
+                                data: {
+                                    $ref: string;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+export declare function DestroyActionTemplate(options: TemplateOptions): {
+    post: {
+        tags: string[];
+        summary: string;
+        parameters: {
+            $ref: string;
+        }[];
+        responses: {
+            '200': {
+                description: string;
+            };
+        };
+    };
+};
+export declare function MoveActionTemplate(options: TemplateOptions): {
+    post: {
+        tags: string[];
+        summary: string;
+        parameters: {
+            name: string;
+            in: string;
+            description: string;
+            schema: {
+                type: string;
+            };
+        }[];
+        responses: {
+            '200': {
+                description: string;
+            };
+        };
+    };
+};
+declare const _default: (collection: Collection) => any;
+export default _default;

package/dist/server/swagger/collections/paths/collection.js

@@ -0,0 +1,362 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var collection_exports = {};
+__export(collection_exports, {
+  CreateActionTemplate: () => CreateActionTemplate,
+  DestroyActionTemplate: () => DestroyActionTemplate,
+  GetActionTemplate: () => GetActionTemplate,
+  ListActionTemplate: () => ListActionTemplate,
+  MoveActionTemplate: () => MoveActionTemplate,
+  UpdateActionTemplate: () => UpdateActionTemplate,
+  default: () => collection_default,
+  relationTypeToString: () => relationTypeToString
+});
+module.exports = __toCommonJS(collection_exports);
+var import_index = require("./index");
+function relationTypeToString(field) {
+  return {
+    belongsTo: "Many to one",
+    hasOne: "One to one",
+    hasMany: "One to many",
+    belongsToMany: "Many to many"
+  }[field.type];
+}
+function ListActionTemplate({ collection, relationField }) {
+  return {
+    get: {
+      tags: [relationField ? `${collection.name}.${relationField.name}` : collection.name],
+      summary: relationField ? `Return a list of ${relationTypeToString(relationField)} relationship` : `Returns a list of the collection`,
+      parameters: [
+        {
+          name: "page",
+          in: "query",
+          description: "page number",
+          required: false,
+          schema: {
+            type: "integer"
+          }
+        },
+        {
+          name: "pageSize",
+          in: "query",
+          description: "page size",
+          required: false,
+          schema: {
+            type: "integer"
+          }
+        },
+        {
+          $ref: "#/components/parameters/filter"
+        },
+        {
+          $ref: "#/components/parameters/sort"
+        },
+        {
+          $ref: "#/components/parameters/fields"
+        },
+        {
+          $ref: "#/components/parameters/appends"
+        },
+        {
+          $ref: "#/components/parameters/except"
+        }
+      ],
+      responses: {
+        "200": {
+          description: "OK",
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  data: {
+                    type: "array",
+                    items: {
+                      $ref: `#/components/schemas/${collection.name}`
+                    }
+                  },
+                  meta: {
+                    type: "object",
+                    properties: {
+                      count: {
+                        type: "integer",
+                        description: "total count"
+                      },
+                      page: {
+                        type: "integer",
+                        description: "current page"
+                      },
+                      pageSize: {
+                        type: "integer",
+                        description: "items count per page"
+                      },
+                      totalPage: {
+                        type: "integer",
+                        description: "total page"
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+}
+function GetActionTemplate(options) {
+  const { collection, relationField } = options;
+  return {
+    get: {
+      tags: [relationField ? `${collection.name}.${relationField.name}` : collection.name],
+      summary: `Return a record${relationField ? ` of ${relationTypeToString(relationField)}` : ""}`,
+      parameters: [
+        {
+          $ref: "#/components/parameters/filterByTk"
+        },
+        {
+          $ref: "#/components/parameters/filter"
+        },
+        {
+          $ref: "#/components/parameters/sort"
+        },
+        {
+          $ref: "#/components/parameters/fields"
+        },
+        {
+          $ref: "#/components/parameters/appends"
+        },
+        {
+          $ref: "#/components/parameters/except"
+        }
+      ],
+      responses: {
+        "200": {
+          description: "OK",
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  data: {
+                    $ref: `#/components/schemas/${collection.name}`
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+}
+function CreateActionTemplate(options) {
+  const { collection, relationField } = options;
+  return {
+    post: {
+      tags: [relationField ? `${collection.name}.${relationField.name}` : collection.name],
+      summary: relationField ? `Create and associate a record` : `Create record`,
+      parameters: [
+        {
+          $ref: "#/components/parameters/whitelist"
+        },
+        {
+          $ref: "#/components/parameters/blacklist"
+        }
+      ],
+      requestBody: {
+        content: {
+          "application/json": {
+            schema: {
+              $ref: `#/components/schemas/${collection.name}.form`
+            }
+          }
+        }
+      },
+      responses: {
+        "200": {
+          description: "OK",
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  data: {
+                    $ref: `#/components/schemas/${collection.name}`
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+}
+function UpdateActionTemplate(options) {
+  const { collection, relationField } = options;
+  return {
+    post: {
+      tags: [relationField ? `${collection.name}.${relationField.name}` : collection.name],
+      summary: relationField ? `Update the relationship record` : `Update record`,
+      parameters: [
+        {
+          $ref: "#/components/parameters/filterByTk"
+        },
+        {
+          $ref: "#/components/parameters/filter"
+        },
+        {
+          $ref: "#/components/parameters/whitelist"
+        },
+        {
+          $ref: "#/components/parameters/blacklist"
+        }
+      ],
+      requestBody: {
+        content: {
+          "application/json": {
+            schema: {
+              $ref: `#/components/schemas/${collection.name}.form`
+            }
+          }
+        }
+      },
+      responses: {
+        "200": {
+          description: "OK",
+          content: {
+            "application/json": {
+              schema: {
+                type: "object",
+                properties: {
+                  data: {
+                    $ref: `#/components/schemas/${collection.name}`
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+}
+function DestroyActionTemplate(options) {
+  const { collection, relationField } = options;
+  return {
+    post: {
+      tags: [relationField ? `${collection.name}.${relationField.name}` : collection.name],
+      summary: relationField ? `Destroy and disassociate the relationship record` : `Delete record`,
+      parameters: [
+        {
+          $ref: "#/components/parameters/filterByTk"
+        },
+        {
+          $ref: "#/components/parameters/filter"
+        }
+      ],
+      responses: {
+        "200": {
+          description: "OK"
+        }
+      }
+    }
+  };
+}
+function MoveActionTemplate(options) {
+  const { collection, relationField } = options;
+  return {
+    post: {
+      tags: [relationField ? `${collection.name}.${relationField.name}` : collection.name],
+      summary: relationField ? `Move the relationship record` : `Move record`,
+      parameters: [
+        {
+          name: "sourceId",
+          in: "query",
+          description: "source id",
+          schema: { type: "string" }
+        },
+        {
+          name: "targetId",
+          in: "query",
+          description: "move target id",
+          schema: { type: "string" }
+        },
+        {
+          name: "method",
+          in: "query",
+          description: "move method, insertAfter or insertBefore",
+          schema: { type: "string" }
+        },
+        {
+          name: "sortField",
+          in: "query",
+          description: "sort field name, default is sort",
+          schema: { type: "string" }
+        },
+        {
+          name: "targetScope",
+          in: "query",
+          description: "move target scope",
+          schema: { type: "string" }
+        },
+        {
+          name: "sticky",
+          in: "query",
+          description: "sticky to top",
+          schema: { type: "boolean" }
+        }
+      ],
+      responses: {
+        "200": {
+          description: "OK"
+        }
+      }
+    }
+  };
+}
+var collection_default = (collection) => {
+  const options = { collection };
+  const apiDoc = {
+    [`/${collection.name}:list`]: ListActionTemplate(options),
+    [`/${collection.name}:get`]: GetActionTemplate(options)
+  };
+  if (!(0, import_index.readOnlyCollection)(collection)) {
+    Object.assign(apiDoc, {
+      [`/${collection.name}:create`]: CreateActionTemplate(options),
+      [`/${collection.name}:update`]: UpdateActionTemplate(options),
+      [`/${collection.name}:destroy`]: DestroyActionTemplate(options)
+    });
+  }
+  if ((0, import_index.hasSortField)(collection)) {
+    apiDoc[`/${collection.name}:move`] = MoveActionTemplate(options);
+  }
+  return apiDoc;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CreateActionTemplate,
+  DestroyActionTemplate,
+  GetActionTemplate,
+  ListActionTemplate,
+  MoveActionTemplate,
+  UpdateActionTemplate,
+  relationTypeToString
+});

package/dist/server/swagger/collections/paths/index.d.ts

@@ -0,0 +1,6 @@
+import { Collection } from '@tachybase/database';
+declare const _default: (collection: Collection, options: any) => any;
+export default _default;
+export declare function hasSortField(collection: Collection): boolean;
+export declare function readOnlyCollection(collection: Collection): boolean;
+export declare function isViewCollection(collection: Collection): boolean;