@strapi/typescript-utils 4.2.0-beta.4 → 4.3.0

package/lib/generators/schemas/utils.js

@@ -0,0 +1,160 @@
+'use strict';
+
+const ts = require('typescript');
+const { factory } = require('typescript');
+const {
+  pipe,
+  replace,
+  camelCase,
+  upperFirst,
+  isUndefined,
+  isNull,
+  isString,
+  isNumber,
+  isDate,
+  isArray,
+  isBoolean,
+  propEq,
+} = require('lodash/fp');
+
+/**
+ * Get all components and content-types in a Strapi application
+ *
+ * @param {Strapi} strapi
+ * @returns {object}
+ */
+const getAllStrapiSchemas = strapi => ({ ...strapi.contentTypes, ...strapi.components });
+
+/**
+ * Extract a valid interface name from a schema uid
+ *
+ * @param {string} uid
+ * @returns {string}
+ */
+const getSchemaInterfaceName = pipe(replace(/(:.)/, ' '), camelCase, upperFirst);
+
+/**
+ * Get the parent type name to extend based on the schema's nature
+ *
+ * @param {object} schema
+ * @returns {string}
+ */
+const getSchemaExtendsTypeName = schema => {
+  const base = getSchemaModelType(schema);
+
+  return upperFirst(base) + 'Schema';
+};
+
+const getSchemaModelType = schema => {
+  const { modelType, kind } = schema;
+
+  // Components
+  if (modelType === 'component') {
+    return 'component';
+  }
+
+  // Content-Types
+  else if (modelType === 'contentType') {
+    return kind;
+  }
+
+  return null;
+};
+
+/**
+ * Get a type node based on a type and its params
+ *
+ * @param {string} typeName
+ * @param {ts.TypeNode[]} [params]
+ * @returns
+ */
+const getTypeNode = (typeName, params = []) => {
+  return factory.createTypeReferenceNode(factory.createIdentifier(typeName), params);
+};
+
+/**
+ * Transform a regular JavaScript object or scalar value into a literal expression
+ * @param data
+ * @returns {ts.TypeNode}
+ */
+const toTypeLiteral = data => {
+  if (isUndefined(data)) {
+    return factory.createLiteralTypeNode(ts.SyntaxKind.UndefinedKeyword);
+  }
+
+  if (isNull(data)) {
+    return factory.createLiteralTypeNode(ts.SyntaxKind.NullKeyword);
+  }
+
+  if (isString(data)) {
+    return factory.createStringLiteral(data, true);
+  }
+
+  if (isNumber(data)) {
+    return factory.createNumericLiteral(data);
+  }
+
+  if (isBoolean(data)) {
+    return data ? factory.createTrue() : factory.createFalse();
+  }
+
+  if (isArray(data)) {
+    return factory.createTupleTypeNode(data.map(item => toTypeLiteral(item)));
+  }
+
+  if (isDate(data)) {
+    return factory.createStringLiteral(data.toISOString());
+  }
+
+  if (typeof data !== 'object') {
+    throw new Error(`Cannot convert to object literal. Unknown type "${typeof data}"`);
+  }
+
+  const entries = Object.entries(data);
+
+  const props = entries.reduce((acc, [key, value]) => {
+    // Handle keys such as content-type-builder & co.
+    const identifier = key.includes('-')
+      ? factory.createStringLiteral(key, true)
+      : factory.createIdentifier(key);
+
+    return [
+      ...acc,
+      factory.createPropertyDeclaration(
+        undefined,
+        undefined,
+        identifier,
+        undefined,
+        toTypeLiteral(value)
+      ),
+    ];
+  }, []);
+
+  return factory.createTypeLiteralNode(props);
+};
+
+/**
+ * Get the number of attributes generated for a given schema definition
+ *
+ * @param {ts.TypeNode} definition
+ * @returns {number | null}
+ */
+const getDefinitionAttributesCount = definition => {
+  const attributesNode = definition.members.find(propEq('name.escapedText', 'attributes'));
+
+  if (!attributesNode) {
+    return null;
+  }
+
+  return attributesNode.type.members.length;
+};
+
+module.exports = {
+  getAllStrapiSchemas,
+  getSchemaInterfaceName,
+  getSchemaExtendsTypeName,
+  getSchemaModelType,
+  getDefinitionAttributesCount,
+  getTypeNode,
+  toTypeLiteral,
+};

package/lib/index.js

@@ -2,11 +2,15 @@
 
 const compile = require('./compile');
 const compilers = require('./compilers');
+const admin = require('./admin');
 const utils = require('./utils');
+const generators = require('./generators');
 
 module.exports = {
   compile,
   compilers,
+  admin,
+  generators,
 
   ...utils,
 };

package/lib/utils/resolve-outdir.js

@@ -8,7 +8,7 @@ const DEFAULT_TS_CONFIG_FILENAME = 'tsconfig.json';
  * Gets the outDir value from config file (tsconfig)
  * @param {string} dir
  * @param {string | undefined} configFilename
- * @returns {string | undefined}
+ * @returns {Promise<string | undefined>}
  */
 module.exports = async (dir, configFilename = DEFAULT_TS_CONFIG_FILENAME) => {
   return (await isUsingTypescript(dir))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/typescript-utils",
-  "version": "4.2.0-beta.4",
+  "version": "4.3.0",
   "description": "Typescript support for Strapi",
   "keywords": [
     "strapi",
@@ -24,13 +24,16 @@
     "lib": "./lib"
   },
   "dependencies": {
+    "chalk": "4.1.2",
+    "cli-table3": "0.6.2",
     "fs-extra": "10.0.1",
     "lodash": "4.17.21",
+    "prettier": "2.7.1",
     "typescript": "4.6.2"
   },
   "engines": {
     "node": ">=12.22.0 <=16.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "5caff35a30e33b7a660eb946299f9e3d2d35b2b8"
+  "gitHead": "74a2b908df75bc8001d72f9dc8571c4b7a2da337"
 }