@tachybase/plugin-devtools 0.23.8

package/dist/server/swagger/collections/components/parameters.d.ts

@@ -0,0 +1,5 @@
+import { Collection } from '@tachybase/database';
+declare const _default: (collection: Collection) => {
+    parameters: {};
+};
+export default _default;

package/dist/server/swagger/collections/components/parameters.js

@@ -0,0 +1,194 @@
+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 parameters_exports = {};
+__export(parameters_exports, {
+  default: () => parameters_default
+});
+module.exports = __toCommonJS(parameters_exports);
+var import_field_type_map = require("./field-type-map");
+var parameters_default = (collection) => {
+  const primaryKey = collection.model.primaryKeyAttribute;
+  const parameters = {};
+  if (primaryKey) {
+    const primaryKeyField = collection.fields.get(primaryKey);
+    if (!primaryKeyField) {
+      throw new Error(`primaryKeyField not found: ${primaryKey}, ${collection.name}`);
+    }
+    Object.assign(parameters, {
+      collectionIndex: {
+        required: true,
+        name: "collectionIndex",
+        in: "path",
+        description: "collection index",
+        schema: (0, import_field_type_map.getTypeByField)(collection.fields.get(primaryKey))
+      },
+      filterByTk: {
+        name: "filterByTk",
+        in: "query",
+        description: "filter by TK(default by ID)",
+        schema: (0, import_field_type_map.getTypeByField)(collection.fields.get(primaryKey))
+      },
+      filterByTks: {
+        name: "filterByTk",
+        in: "query",
+        description: "filter by TKs(default by ID), example: `1,2,3`",
+        schema: {
+          type: "array",
+          items: (0, import_field_type_map.getTypeByField)(collection.fields.get(primaryKey))
+        }
+      }
+    });
+  }
+  Object.assign(parameters, {
+    filter: {
+      name: "filter",
+      in: "query",
+      description: "filter items",
+      content: {
+        "application/json": {
+          schema: {
+            type: "object"
+          }
+        }
+      }
+    },
+    sort: {
+      name: "sort",
+      in: "query",
+      description: "sort items by fields, example: `-field1,-field2,field3`",
+      schema: {
+        oneOf: [
+          {
+            type: "array",
+            items: {
+              type: "string"
+            },
+            example: ["-id", "createdAt"]
+          },
+          {
+            type: "string",
+            example: "-id,createdAt"
+          }
+        ]
+      }
+    },
+    fields: {
+      name: "fields",
+      in: "query",
+      description: "select fields, example: `field1,field2`",
+      schema: {
+        oneOf: [
+          {
+            type: "array",
+            items: {
+              type: "string"
+            },
+            example: ["id", "createdAt"]
+          },
+          {
+            type: "string",
+            example: "id,createdAt"
+          }
+        ]
+      }
+    },
+    except: {
+      name: "except",
+      in: "query",
+      description: "except fields in results, example: `field1,field2`",
+      schema: {
+        oneOf: [
+          {
+            type: "array",
+            items: {
+              type: "string"
+            },
+            example: ["id", "createdAt"]
+          },
+          {
+            type: "string",
+            example: "id,createdAt"
+          }
+        ]
+      }
+    },
+    appends: {
+      name: "appends",
+      in: "query",
+      description: "append associations in results, example: `assoc1,assoc2`",
+      schema: {
+        oneOf: [
+          {
+            type: "array",
+            items: {
+              type: "string"
+            },
+            example: ["id", "createdAt"]
+          },
+          {
+            type: "string",
+            example: "id,createdAt"
+          }
+        ]
+      }
+    },
+    whitelist: {
+      name: "whitelist",
+      in: "query",
+      description: "whitelist for fields changes, example: `field1,field2`",
+      schema: {
+        oneOf: [
+          {
+            type: "array",
+            items: {
+              type: "string"
+            },
+            example: ["id", "createdAt"]
+          },
+          {
+            type: "string",
+            example: "id,createdAt"
+          }
+        ]
+      }
+    },
+    blacklist: {
+      name: "blacklist",
+      in: "query",
+      description: "blacklist for fields changes, example: `field1,field2`",
+      schema: {
+        oneOf: [
+          {
+            type: "array",
+            items: {
+              type: "string"
+            },
+            example: ["id", "createdAt"]
+          },
+          {
+            type: "string",
+            example: "id,createdAt"
+          }
+        ]
+      }
+    }
+  });
+  return {
+    parameters
+  };
+};

package/dist/server/swagger/collections/components/schemas.d.ts

@@ -0,0 +1,23 @@
+import { Collection } from '@tachybase/database';
+declare const _default: (collection: Collection, options: any) => {
+    schemas: {
+        [x: string]: {
+            type: string;
+            properties: {};
+            allOf?: undefined;
+        } | {
+            allOf: ({
+                $ref: string;
+                type?: undefined;
+                properties?: undefined;
+            } | {
+                type: string;
+                properties: any;
+                $ref?: undefined;
+            })[];
+            type?: undefined;
+            properties?: undefined;
+        };
+    };
+};
+export default _default;

package/dist/server/swagger/collections/components/schemas.js

@@ -0,0 +1,108 @@
+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 schemas_exports = {};
+__export(schemas_exports, {
+  default: () => schemas_default
+});
+module.exports = __toCommonJS(schemas_exports);
+var import_database = require("@tachybase/database");
+var import_associations = require("../paths/associations");
+var import_field_type_map = require("./field-type-map");
+function getCollectionReadOnlyFields(collection) {
+  var _a;
+  const readOnlyFields = [];
+  const primaryKey = collection.model.primaryKeyAttribute;
+  if (primaryKey) {
+    const primaryField = collection.fields.get(primaryKey);
+    if (primaryField && ((_a = primaryField.options) == null ? void 0 : _a.autoIncrement)) {
+      readOnlyFields.push(primaryKey);
+    }
+  }
+  for (const [fieldName, field] of collection.fields) {
+    if (field.type === "sort") {
+      readOnlyFields.push(fieldName);
+      continue;
+    }
+    if (field.type === "context") {
+      readOnlyFields.push(fieldName);
+      continue;
+    }
+    if ([
+      "createdAt",
+      "updatedAt",
+      "created_at",
+      "updated_at",
+      "sort",
+      "created_by_id",
+      "createdById",
+      "updatedById",
+      "updated_by_id"
+    ].includes(fieldName)) {
+      readOnlyFields.push(fieldName);
+      continue;
+    }
+  }
+  return readOnlyFields;
+}
+function collectionToSchema(collection) {
+  return {
+    [collection.name]: {
+      type: "object",
+      properties: Array.from(collection.fields).filter(([key, value]) => {
+        return !(value instanceof import_database.RelationField);
+      }).reduce((obj, [key, value]) => {
+        obj[key] = {
+          ...getFieldTypeAttributes(value)
+        };
+        return obj;
+      }, {})
+    },
+    [`${collection.name}.form`]: {
+      allOf: [
+        {
+          $ref: `#/components/schemas/${collection.name}`
+        },
+        {
+          type: "object",
+          properties: getCollectionReadOnlyFields(collection).reduce((obj, key) => {
+            obj[key] = {
+              readOnly: true
+            };
+            return obj;
+          }, {})
+        }
+      ]
+    }
+  };
+}
+var schemas_default = (collection, options) => {
+  const associations = (0, import_associations.associationFields)(collection);
+  const associationsTarget = associations.map((field) => collection.db.getCollection(field.target));
+  const schemas = collectionToSchema(collection);
+  if (options.withAssociation) {
+    for (const target of associationsTarget) {
+      Object.assign(schemas, collectionToSchema(target));
+    }
+  }
+  return {
+    schemas
+  };
+};
+function getFieldTypeAttributes(field) {
+  return (0, import_field_type_map.getTypeByField)(field);
+}

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

@@ -0,0 +1,31 @@
+import { Collection } from '@tachybase/database';
+declare function collectionToSwaggerObject(collection: Collection, options: any): {
+    paths: any;
+    components: {
+        parameters: {};
+        schemas: {
+            [x: string]: {
+                type: string;
+                properties: {};
+                allOf?: undefined;
+            } | {
+                allOf: ({
+                    $ref: string;
+                    type?: undefined;
+                    properties?: undefined;
+                } | {
+                    type: string;
+                    properties: any;
+                    $ref?: undefined;
+                })[];
+                type?: undefined;
+                properties?: undefined;
+            };
+        };
+    };
+    tags: {
+        name: string;
+        description: string;
+    }[];
+};
+export default collectionToSwaggerObject;

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

@@ -0,0 +1,43 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var collections_exports = {};
+__export(collections_exports, {
+  default: () => collections_default
+});
+module.exports = __toCommonJS(collections_exports);
+var import_components = __toESM(require("./components"));
+var import_paths = __toESM(require("./paths"));
+var import_tags = __toESM(require("./tags"));
+function collectionToSwaggerObject(collection, options) {
+  return {
+    paths: (0, import_paths.default)(collection, options),
+    components: (0, import_components.default)(collection, options),
+    tags: (0, import_tags.default)(collection, options)
+  };
+}
+var collections_default = collectionToSwaggerObject;

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

@@ -0,0 +1,6 @@
+import { Collection, RelationField } from '@tachybase/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,60 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var associations_exports = {};
+__export(associations_exports, {
+  associationFields: () => associationFields,
+  default: () => associations_default
+});
+module.exports = __toCommonJS(associations_exports);
+var import_database = require("@tachybase/database");
+var import__ = require("..");
+var import_multiple_association = __toESM(require("./multiple-association"));
+var import_single_association = __toESM(require("./single-association"));
+var associations_default = (collection) => {
+  return associationFields(collection).map((field) => {
+    if (field.type === "belongsToMany" || field.type === "hasMany") {
+      return (0, import_multiple_association.default)(collection, field);
+    }
+    return (0, import_single_association.default)(collection, field);
+  }).reduce((obj, item) => {
+    return {
+      ...obj,
+      ...item
+    };
+  }, {});
+};
+function associationFields(collection) {
+  if ((0, import__.isViewCollection)(collection)) {
+    return [];
+  }
+  return Array.from(collection.fields.values()).filter((field) => field instanceof import_database.RelationField).filter((field) => field.name !== "createdBy" && field.name !== "updatedBy");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  associationFields
+});

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

@@ -0,0 +1,6 @@
+import { BelongsToManyField, Collection, HasManyField } from '@tachybase/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,125 @@
+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 multiple_association_exports = {};
+__export(multiple_association_exports, {
+  appendCollectionIndexParams: () => appendCollectionIndexParams,
+  default: () => multiple_association_default
+});
+module.exports = __toCommonJS(multiple_association_exports);
+var import_collection = require("../collection");
+var import__ = 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, relationField) => {
+  const options = {
+    collection,
+    relationField
+  };
+  const targetCollection = collection.db.getCollection(relationField.target);
+  const paths = {
+    [`/${collection.name}/{collectionIndex}/${relationField.name}:list`]: appendCollectionIndexParams(
+      (0, import_collection.ListActionTemplate)(options)
+    ),
+    [`/${collection.name}/{collectionIndex}/${relationField.name}:get`]: appendCollectionIndexParams(
+      (0, import_collection.GetActionTemplate)(options)
+    ),
+    [`/${collection.name}/{collectionIndex}/${relationField.name}:create`]: appendCollectionIndexParams(
+      (0, import_collection.CreateActionTemplate)(options)
+    ),
+    [`/${collection.name}/{collectionIndex}/${relationField.name}:update`]: appendCollectionIndexParams(
+      (0, import_collection.UpdateActionTemplate)(options)
+    ),
+    [`/${collection.name}/{collectionIndex}/${relationField.name}:destroy`]: appendCollectionIndexParams(
+      (0, import_collection.DestroyActionTemplate)(options)
+    ),
+    [`/${collection.name}/{collectionIndex}/${relationField.name}:set`]: appendCollectionIndexParams({
+      post: {
+        tags: [`${collection.name}.${relationField.name}`],
+        summary: "Set or reset associations",
+        parameters: [
+          {
+            $ref: "#/components/parameters/filterByTk"
+          },
+          {
+            $ref: "#/components/parameters/filterByTks"
+          }
+        ],
+        responses: {
+          "200": {
+            description: "OK"
+          }
+        }
+      }
+    }),
+    [`/${collection.name}/{collectionIndex}/${relationField.name}:remove`]: appendCollectionIndexParams({
+      post: {
+        tags: [`${collection.name}.${relationField.name}`],
+        summary: "Detach record",
+        parameters: [
+          {
+            $ref: "#/components/parameters/filterByTk"
+          },
+          {
+            $ref: "#/components/parameters/filterByTks"
+          }
+        ],
+        responses: {
+          "200": {
+            description: "OK"
+          }
+        }
+      }
+    }),
+    [`/${collection.name}/{collectionIndex}/${relationField.name}:toggle`]: appendCollectionIndexParams({
+      post: {
+        tags: [`${collection.name}.${relationField.name}`],
+        summary: "Attach or detach record",
+        parameters: [
+          {
+            $ref: "#/components/parameters/filterByTk"
+          }
+        ],
+        responses: {
+          "200": {
+            description: "OK"
+          }
+        }
+      }
+    })
+  };
+  if ((0, import__.hasSortField)(collection)) {
+    paths[`/${collection.name}/{collectionIndex}/${relationField.name}:move`] = appendCollectionIndexParams(
+      (0, import_collection.MoveActionTemplate)(options)
+    );
+  }
+  return paths;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  appendCollectionIndexParams
+});

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

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