@nocobase/plugin-api-doc 0.13.0-alpha.1

package/dist/server/swagger/collections/index.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var paths = require('./paths');
+var components = require('./components');
+var tags = require('./tags');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var paths__default = /*#__PURE__*/_interopDefault(paths);
+var components__default = /*#__PURE__*/_interopDefault(components);
+var tags__default = /*#__PURE__*/_interopDefault(tags);
+
+function collectionToSwaggerObject(collection, options) {
+  return {
+    paths: paths__default.default(collection, options),
+    components: components__default.default(collection, options),
+    tags: tags__default.default(collection, options)
+  };
+}
+var collections_default = collectionToSwaggerObject;
+
+module.exports = collections_default;

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

@@ -0,0 +1,6 @@
+import { Collection, RelationField } from '@nocobase/database';
+declare const _default: (collection: Collection) => {
+    [x: string]: object;
+};
+export default _default;
+export declare function associationFields(collection: Collection): Array<RelationField>;

package/dist/server/swagger/collections/paths/associations/index.js

@@ -0,0 +1,32 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var database = require('@nocobase/database');
+var multipleAssociation = require('./multiple-association');
+var singleAssociation = require('./single-association');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var multipleAssociation__default = /*#__PURE__*/_interopDefault(multipleAssociation);
+var singleAssociation__default = /*#__PURE__*/_interopDefault(singleAssociation);
+
+var associations_default = (collection) => {
+  return associationFields(collection).map((field) => {
+    if (field.type === "belongsToMany" || field.type === "hasMany") {
+      return multipleAssociation__default.default(collection, field);
+    }
+    return singleAssociation__default.default(collection, field);
+  }).reduce((obj, item) => {
+    return {
+      ...obj,
+      ...item
+    };
+  }, {});
+};
+function associationFields(collection) {
+  return Array.from(collection.fields.values()).filter((field) => field instanceof database.RelationField).filter((field) => field.name !== "createdBy" && field.name !== "updatedBy");
+}
+
+exports.associationFields = associationFields;
+exports.default = associations_default;

package/dist/server/swagger/collections/paths/associations/multiple-association.d.ts

@@ -0,0 +1,6 @@
+import { BelongsToManyField, Collection, HasManyField } from '@nocobase/database';
+export declare function appendCollectionIndexParams(apiDef: object): object;
+declare const _default: (collection: Collection, relationField: HasManyField | BelongsToManyField) => {
+    [x: string]: object;
+};
+export default _default;

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

@@ -0,0 +1,106 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var collection = require('../collection');
+var index = require('../index');
+
+function appendCollectionIndexParams(apiDef) {
+  for (const action of Object.keys(apiDef)) {
+    const parameters = apiDef[action]["parameters"];
+    if (!parameters) {
+      apiDef[action]["parameters"] = [];
+    }
+    apiDef[action]["parameters"].unshift({
+      $ref: "#/components/parameters/collectionIndex"
+    });
+  }
+  return apiDef;
+}
+var multiple_association_default = (collection$1, relationField) => {
+  const options = {
+    collection: collection$1,
+    relationField
+  };
+  collection$1.db.getCollection(relationField.target);
+  const paths = {
+    [`/${collection$1.name}/{collectionIndex}/${relationField.name}:list`]: appendCollectionIndexParams(
+      collection.ListActionTemplate(options)
+    ),
+    [`/${collection$1.name}/{collectionIndex}/${relationField.name}:get`]: appendCollectionIndexParams(
+      collection.GetActionTemplate(options)
+    ),
+    [`/${collection$1.name}/{collectionIndex}/${relationField.name}:create`]: appendCollectionIndexParams(
+      collection.CreateActionTemplate(options)
+    ),
+    [`/${collection$1.name}/{collectionIndex}/${relationField.name}:update`]: appendCollectionIndexParams(
+      collection.UpdateActionTemplate(options)
+    ),
+    [`/${collection$1.name}/{collectionIndex}/${relationField.name}:destroy`]: appendCollectionIndexParams(
+      collection.DestroyActionTemplate(options)
+    ),
+    [`/${collection$1.name}/{collectionIndex}/${relationField.name}:set`]: appendCollectionIndexParams({
+      post: {
+        tags: [`${collection$1.name}.${relationField.name}`],
+        summary: "Set or reset associations",
+        parameters: [
+          {
+            $ref: "#/components/parameters/filterByTk"
+          },
+          {
+            $ref: "#/components/parameters/filterByTks"
+          }
+        ],
+        responses: {
+          "200": {
+            description: "OK"
+          }
+        }
+      }
+    }),
+    [`/${collection$1.name}/{collectionIndex}/${relationField.name}:remove`]: appendCollectionIndexParams({
+      post: {
+        tags: [`${collection$1.name}.${relationField.name}`],
+        summary: "Detach record",
+        parameters: [
+          {
+            $ref: "#/components/parameters/filterByTk"
+          },
+          {
+            $ref: "#/components/parameters/filterByTks"
+          }
+        ],
+        responses: {
+          "200": {
+            description: "OK"
+          }
+        }
+      }
+    }),
+    [`/${collection$1.name}/{collectionIndex}/${relationField.name}:toggle`]: appendCollectionIndexParams({
+      post: {
+        tags: [`${collection$1.name}.${relationField.name}`],
+        summary: "Attach or detach record",
+        parameters: [
+          {
+            $ref: "#/components/parameters/filterByTk"
+          }
+        ],
+        responses: {
+          "200": {
+            description: "OK"
+          }
+        }
+      }
+    })
+  };
+  if (index.hasSortField(collection$1)) {
+    paths[`/${collection$1.name}/{collectionIndex}/${relationField.name}:move`] = appendCollectionIndexParams(
+      collection.MoveActionTemplate(options)
+    );
+  }
+  return paths;
+};
+
+exports.appendCollectionIndexParams = appendCollectionIndexParams;
+exports.default = multiple_association_default;

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

@@ -0,0 +1,5 @@
+import { BelongsToField, Collection, HasOneField } from '@nocobase/database';
+declare const _default: (collection: Collection, relationField: HasOneField | BelongsToField) => {
+    [x: string]: object;
+};
+export default _default;

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

@@ -0,0 +1,88 @@
+'use strict';
+
+var multipleAssociation = require('./multiple-association');
+var collection = require('../collection');
+
+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$1, relationField) => {
+  const options = {
+    collection: collection$1,
+    relationField
+  };
+  return {
+    [`/${collection$1.name}/{collectionIndex}/${relationField.name}:get`]: removeFilterByTkParams(
+      filterSingleAssociationParams(multipleAssociation.appendCollectionIndexParams(collection.GetActionTemplate(options)))
+    ),
+    [`/${collection$1.name}/{collectionIndex}/${relationField.name}:set`]: multipleAssociation.appendCollectionIndexParams({
+      post: {
+        tags: [`${collection$1.name}.${relationField.name}`],
+        summary: "Associate a record",
+        parameters: [
+          {
+            name: "tk",
+            in: "query",
+            description: "targetKey",
+            schema: {
+              type: "string"
+            }
+          }
+        ],
+        responses: {
+          "200": {
+            description: "OK"
+          }
+        }
+      }
+    }),
+    [`/${collection$1.name}/{collectionIndex}/${relationField.name}:remove`]: multipleAssociation.appendCollectionIndexParams({
+      post: {
+        tags: [`${collection$1.name}.${relationField.name}`],
+        summary: "Disassociate the relationship record",
+        responses: {
+          "200": {
+            description: "OK"
+          }
+        }
+      }
+    }),
+    [`/${collection$1.name}/{collectionIndex}/${relationField.name}:update`]: removeFilterByTkParams(
+      filterSingleAssociationParams(multipleAssociation.appendCollectionIndexParams(collection.UpdateActionTemplate(options)))
+    ),
+    [`/${collection$1.name}/{collectionIndex}/${relationField.name}:create`]: removeFilterByTkParams(
+      filterSingleAssociationParams(multipleAssociation.appendCollectionIndexParams(collection.CreateActionTemplate(options)))
+    ),
+    [`/${collection$1.name}/{collectionIndex}/${relationField.name}:destroy`]: removeFilterByTkParams(
+      filterSingleAssociationParams(multipleAssociation.appendCollectionIndexParams(collection.DestroyActionTemplate(options)))
+    )
+  };
+};
+
+module.exports = single_association_default;

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

@@ -0,0 +1,201 @@
+import { Collection, RelationField } from '@nocobase/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;