@xube/kit-generator 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./type/exports";
+export * from "./type/identifier";
+export * from "./type/predicates";
+export * from "./type/type-helpers";
+export * from "./type/type-schema";
+export * from "./type/types";
+export * from "./type/validators";

package/dist/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./type/exports"), exports);
+__exportStar(require("./type/identifier"), exports);
+__exportStar(require("./type/predicates"), exports);
+__exportStar(require("./type/type-helpers"), exports);
+__exportStar(require("./type/type-schema"), exports);
+__exportStar(require("./type/types"), exports);
+__exportStar(require("./type/validators"), exports);

package/dist/type/exports.d.ts

@@ -0,0 +1,2 @@
+import { GeneratedFilePath } from "./type-helpers";
+export declare const generateExportIndex: (filePaths: string[], rootDir: string) => GeneratedFilePath;

package/dist/type/exports.js

@@ -0,0 +1,53 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateExportIndex = void 0;
+const fs_1 = require("fs");
+const pascal_case_1 = require("pascal-case");
+const path_1 = __importStar(require("path"));
+const isValidatorPath = (filePath) => filePath.includes("validators/");
+const generateExportIndex = (filePaths, rootDir) => {
+    const dir = (0, path_1.join)(rootDir, "generated");
+    const exports = filePaths.map((filePath) => {
+        let exportString = "export ";
+        if (isValidatorPath(filePath)) {
+            exportString += `{validate as validate${(0, pascal_case_1.pascalCase)(path_1.default.parse(filePath).name)}} `;
+        }
+        else {
+            exportString += "* ";
+        }
+        return (exportString += `from '.${filePath
+            .replace(dir, "")
+            .replace(".js", "")
+            .replace(".ts", "")}'`);
+    });
+    const indexFilePath = (0, path_1.join)(dir, "index.ts");
+    (0, fs_1.writeFileSync)(indexFilePath, exports.join("\n"), {
+        flag: "w+",
+    });
+    console.log("Exported generated files");
+    return indexFilePath;
+};
+exports.generateExportIndex = generateExportIndex;

package/dist/type/identifier.d.ts

@@ -0,0 +1 @@
+export declare const getIdentifierFromName: (name: string) => string;

package/dist/type/identifier.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIdentifierFromName = void 0;
+const pascal_case_1 = require("pascal-case");
+const getIdentifierFromName = (name) => {
+    const nameParts = name.split("_");
+    return nameParts.reduce((acc, curr, idx) => {
+        if (idx === 0) {
+            return `${acc}${(0, pascal_case_1.pascalCase)(curr)}`;
+        }
+        return `${acc}_${(0, pascal_case_1.pascalCase)(curr)}`;
+    }, "");
+};
+exports.getIdentifierFromName = getIdentifierFromName;

package/dist/type/predicates.d.ts

@@ -0,0 +1,2 @@
+import { GeneratedFilePath } from "./type-helpers";
+export declare const generateTypePredicateFromTypeAndValidator: (name: string, generatedTypeFilePath: GeneratedFilePath) => GeneratedFilePath;

package/dist/type/predicates.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTypePredicateFromTypeAndValidator = void 0;
+const fs_1 = require("fs");
+const validators_1 = require("./validators");
+const identifier_1 = require("./identifier");
+const generateTypePredicateFromTypeAndValidator = (name, generatedTypeFilePath) => {
+    const identifier = (0, identifier_1.getIdentifierFromName)(name);
+    const predicate = `
+  \n
+  import { XubeLog } from "@xube/kit-log";
+  import validate from "${(0, validators_1.getImportableValidatorFilePathRelativeToGeneratedFolder)(name)}";\n
+  export const is${identifier} = (item: unknown): item is ${identifier} => {
+  \tconst isValid: boolean = validate(item);
+  \tif(!isValid){
+  \t\tXubeLog.getInstance().info(JSON.stringify((validate as typeof validate & {errors: object}).errors, null, 2));
+  \t}
+  \treturn isValid;
+  }
+  `;
+    (0, fs_1.appendFileSync)(generatedTypeFilePath, predicate);
+    console.log(`${name} type predicated generated`);
+    return generatedTypeFilePath;
+};
+exports.generateTypePredicateFromTypeAndValidator = generateTypePredicateFromTypeAndValidator;

package/dist/type/type-helpers.d.ts

@@ -0,0 +1 @@
+export type GeneratedFilePath = string;

package/dist/type/type-helpers.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/type/type-schema.d.ts

@@ -0,0 +1,7 @@
+import { ZodTypeAny } from "zod";
+export * from "./predicates";
+export * from "./type-helpers";
+export * from "./types";
+export * from "./validators";
+export * from "./exports";
+export declare const generateTypeSchemaFiles: (name: string, schema: ZodTypeAny, rootDir: string) => [string, string];

package/dist/type/type-schema.js

@@ -0,0 +1,33 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTypeSchemaFiles = void 0;
+const types_1 = require("./types");
+const validators_1 = require("./validators");
+const predicates_1 = require("./predicates");
+__exportStar(require("./predicates"), exports);
+__exportStar(require("./type-helpers"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./validators"), exports);
+__exportStar(require("./exports"), exports);
+const generateTypeSchemaFiles = (name, schema, rootDir) => {
+    const validatorFilePath = (0, validators_1.generateValidatorsFromZodSchema)(name, schema, rootDir);
+    const typeFilePath = (0, types_1.generateTypesFromZodSchema)(name, schema, rootDir);
+    (0, predicates_1.generateTypePredicateFromTypeAndValidator)(name, typeFilePath);
+    console.log(`${name} type, type predicate and schema generated`);
+    return [validatorFilePath, typeFilePath];
+};
+exports.generateTypeSchemaFiles = generateTypeSchemaFiles;

package/dist/type/types.d.ts

@@ -0,0 +1,9 @@
+import { ZodTypeAny } from "zod";
+import { GeneratedFilePath } from "./type-helpers";
+/**
+ * Function that generates TS Type from Zod Schema
+ *
+ * @param name The name of the schema. The outputted compiled validation file will be <name>.ts
+ * @param schema The zod schema
+ */
+export declare const generateTypesFromZodSchema: (name: string, schema: ZodTypeAny, rootDir: string) => GeneratedFilePath;

package/dist/type/types.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTypesFromZodSchema = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const zod_to_ts_1 = require("zod-to-ts");
+const identifier_1 = require("./identifier");
+/**
+ * Function that generates TS Type from Zod Schema
+ *
+ * @param name The name of the schema. The outputted compiled validation file will be <name>.ts
+ * @param schema The zod schema
+ */
+const generateTypesFromZodSchema = (name, schema, rootDir) => {
+    if (!name) {
+        throw Error("Name must not be empty");
+    }
+    const identifier = (0, identifier_1.getIdentifierFromName)(name);
+    const typeAlias = (0, zod_to_ts_1.createTypeAlias)((0, zod_to_ts_1.zodToTs)(schema).node, identifier);
+    const dir = (0, path_1.join)(rootDir, "generated", "types");
+    (0, fs_1.mkdirSync)(dir, { recursive: true });
+    const generatedFilePath = (0, path_1.join)(dir, `${name}.ts`);
+    const fileContents = `
+  /**
+   * I am a generated file.
+   *
+   * If you change me, you and other developers will be sad.
+   *
+   * #StayGeneratedStayHappy
+   */
+
+  export ${(0, zod_to_ts_1.printNode)(typeAlias)}
+  `;
+    (0, fs_1.writeFileSync)(generatedFilePath, fileContents, {
+        flag: "w+",
+    });
+    console.log(`${name} type created`);
+    return generatedFilePath;
+};
+exports.generateTypesFromZodSchema = generateTypesFromZodSchema;

package/dist/type/validators.d.ts

@@ -0,0 +1,10 @@
+import { ZodType, ZodTypeDef } from "zod";
+import { GeneratedFilePath } from "./type-helpers";
+/**
+ * Function that generates compiled ajv validation for fast validation of unknown data
+ *
+ * @param name The name of the schema. The outputted compiled validation file will be <name>.js
+ * @param schema The zod schema
+ */
+export declare const generateValidatorsFromZodSchema: (name: string, schema: ZodType<any, ZodTypeDef, any>, rootDir: string) => GeneratedFilePath;
+export declare const getImportableValidatorFilePathRelativeToGeneratedFolder: (name: string) => string;

package/dist/type/validators.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getImportableValidatorFilePathRelativeToGeneratedFolder = exports.generateValidatorsFromZodSchema = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const ajv_1 = __importDefault(require("ajv"));
+const standalone_1 = __importDefault(require("ajv/dist/standalone"));
+const ajv_formats_1 = __importDefault(require("ajv-formats"));
+const zod_to_json_schema_1 = __importDefault(require("zod-to-json-schema"));
+/**
+ * Function that generates compiled ajv validation for fast validation of unknown data
+ *
+ * @param name The name of the schema. The outputted compiled validation file will be <name>.js
+ * @param schema The zod schema
+ */
+const generateValidatorsFromZodSchema = (name, schema, rootDir) => {
+    const ajv = new ajv_1.default({
+        $data: true,
+        allErrors: true,
+        useDefaults: true,
+        code: {
+            esm: true,
+            source: true,
+        },
+        strict: true,
+    });
+    (0, ajv_formats_1.default)(ajv);
+    const validationCode = (0, standalone_1.default)(ajv, ajv.compile((0, zod_to_json_schema_1.default)(schema, `${name.toLowerCase()}JsonSchema`)));
+    const dir = (0, path_1.join)(rootDir, "generated", "validators");
+    (0, fs_1.mkdirSync)(dir, { recursive: true });
+    const generatedFilePath = (0, path_1.join)(dir, `${name}.js`);
+    (0, fs_1.writeFileSync)(generatedFilePath, validationCode, {
+        flag: "w+",
+    });
+    console.log(`${name} validator created`);
+    return generatedFilePath;
+};
+exports.generateValidatorsFromZodSchema = generateValidatorsFromZodSchema;
+const getImportableValidatorFilePathRelativeToGeneratedFolder = (name) => {
+    return `../validators/${name}`;
+};
+exports.getImportableValidatorFilePathRelativeToGeneratedFolder = getImportableValidatorFilePathRelativeToGeneratedFolder;

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@xube/kit-generator",
+  "version": "0.0.1",
+  "description": "",
+  "main": "dist/index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/XubeLtd/dev-kit.git"
+  },
+  "author": "Xube Pty Ltd",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/XubeLtd/dev-kit/issues"
+  },
+  "homepage": "https://github.com/XubeLtd/dev-kit#readme",
+  "dependencies": {
+    "ajv": "^8.12.0",
+    "ajv-formats": "^2.1.1",
+    "pascal-case": "^3.1.2",
+    "zod": "^3.21.4",
+    "zod-to-json-schema": "^3.21.4",
+    "zod-to-ts": "^1.1.4"
+  },
+  "devDependencies": {
+    "@types/node": "^20.4.7",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.1.6"
+  }
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from "./type/exports";
+export * from "./type/identifier";
+export * from "./type/predicates";
+export * from "./type/type-helpers";
+export * from "./type/type-schema";
+export * from "./type/types";
+export * from "./type/validators";

package/src/type/exports.ts

@@ -0,0 +1,38 @@
+import { writeFileSync } from "fs";
+import { pascalCase } from "pascal-case";
+import path, { join } from "path";
+import { GeneratedFilePath } from "./type-helpers";
+
+const isValidatorPath = (filePath: string) =>
+  filePath.includes("validators/");
+
+export const generateExportIndex = (
+  filePaths: string[],
+  rootDir: string
+): GeneratedFilePath => {
+  const dir: string = join(rootDir, "generated");
+  const exports: string[] = filePaths.map((filePath) => {
+    let exportString = "export ";
+    if (isValidatorPath(filePath)) {
+      exportString += `{validate as validate${pascalCase(
+        path.parse(filePath).name
+      )}} `;
+    } else {
+      exportString += "* ";
+    }
+    return (exportString += `from '.${filePath
+      .replace(dir, "")
+      .replace(".js", "")
+      .replace(".ts", "")}'`);
+  });
+
+  const indexFilePath: GeneratedFilePath = join(dir, "index.ts");
+
+  writeFileSync(indexFilePath, exports.join("\n"), {
+    flag: "w+",
+  });
+
+  console.log("Exported generated files");
+
+  return indexFilePath;
+};

package/src/type/identifier.ts

@@ -0,0 +1,11 @@
+import { pascalCase } from "pascal-case";
+
+export const getIdentifierFromName = (name: string): string => {
+  const nameParts: string[] = name.split("_");
+  return nameParts.reduce((acc, curr, idx) => {
+    if (idx === 0) {
+      return `${acc}${pascalCase(curr)}`;
+    }
+    return `${acc}_${pascalCase(curr)}`;
+  }, "");
+}

package/src/type/predicates.ts

@@ -0,0 +1,32 @@
+import { appendFileSync } from "fs";
+import { GeneratedFilePath } from "./type-helpers";
+import { getImportableValidatorFilePathRelativeToGeneratedFolder } from "./validators";
+import { getIdentifierFromName } from "./identifier";
+
+export const generateTypePredicateFromTypeAndValidator = (
+  name: string,
+  generatedTypeFilePath: GeneratedFilePath
+): GeneratedFilePath => {
+  const identifier = getIdentifierFromName(name);
+
+  const predicate: string = `
+  \n
+  import { XubeLog } from "@xube/kit-log";
+  import validate from "${getImportableValidatorFilePathRelativeToGeneratedFolder(
+    name
+  )}";\n
+  export const is${identifier} = (item: unknown): item is ${identifier} => {
+  \tconst isValid: boolean = validate(item);
+  \tif(!isValid){
+  \t\tXubeLog.getInstance().info(JSON.stringify((validate as typeof validate & {errors: object}).errors, null, 2));
+  \t}
+  \treturn isValid;
+  }
+  `;
+
+  appendFileSync(generatedTypeFilePath, predicate);
+
+  console.log(`${name} type predicated generated`);
+
+  return generatedTypeFilePath;
+};

package/src/type/type-helpers.ts

@@ -0,0 +1,2 @@
+
+export type GeneratedFilePath = string;

package/src/type/type-schema.ts

@@ -0,0 +1,33 @@
+import { ZodTypeAny } from "zod";
+import { generateTypesFromZodSchema } from "./types";
+import { generateValidatorsFromZodSchema } from "./validators";
+import { GeneratedFilePath } from "./type-helpers";
+import { generateTypePredicateFromTypeAndValidator } from "./predicates";
+
+export * from "./predicates"
+export * from "./type-helpers";
+export * from "./types";
+export * from "./validators";
+export * from "./exports";
+
+export const generateTypeSchemaFiles = (
+  name: string,
+  schema: ZodTypeAny,
+  rootDir: string
+): [string, string] => {
+  const validatorFilePath: GeneratedFilePath = generateValidatorsFromZodSchema(
+    name,
+    schema,
+    rootDir
+  );
+  const typeFilePath: GeneratedFilePath = generateTypesFromZodSchema(
+    name,
+    schema,
+    rootDir
+  );
+  generateTypePredicateFromTypeAndValidator(name, typeFilePath);
+
+  console.log(`${name} type, type predicate and schema generated`)
+
+  return [validatorFilePath, typeFilePath]
+};

package/src/type/types.ts

@@ -0,0 +1,50 @@
+import { mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+import { ZodTypeAny } from "zod";
+import { createTypeAlias, printNode, zodToTs } from "zod-to-ts";
+import { GeneratedFilePath } from "./type-helpers";
+import { getIdentifierFromName } from "./identifier";
+/**
+ * Function that generates TS Type from Zod Schema
+ *
+ * @param name The name of the schema. The outputted compiled validation file will be <name>.ts
+ * @param schema The zod schema
+ */
+export const generateTypesFromZodSchema = (
+  name: string,
+  schema: ZodTypeAny,
+  rootDir: string
+): GeneratedFilePath => {
+  if (!name) {
+    throw Error("Name must not be empty");
+  }
+
+  const identifier = getIdentifierFromName(name);
+
+  const typeAlias = createTypeAlias(zodToTs(schema).node, identifier);
+
+  const dir: string = join(rootDir, "generated", "types");
+  mkdirSync(dir, { recursive: true });
+
+  const generatedFilePath: GeneratedFilePath = join(dir, `${name}.ts`);
+
+  const fileContents: string = `
+  /**
+   * I am a generated file.
+   *
+   * If you change me, you and other developers will be sad.
+   *
+   * #StayGeneratedStayHappy
+   */
+
+  export ${printNode(typeAlias)}
+  `;
+
+  writeFileSync(generatedFilePath, fileContents, {
+    flag: "w+",
+  });
+
+  console.log(`${name} type created`);
+
+  return generatedFilePath;
+};

package/src/type/validators.ts

@@ -0,0 +1,57 @@
+import { mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+
+import Ajv from "ajv";
+import standaloneCode from "ajv/dist/standalone";
+import addFormats from "ajv-formats";
+
+import zodToJsonSchema from "zod-to-json-schema";
+import { ZodType, ZodTypeDef } from "zod";
+import { GeneratedFilePath } from "./type-helpers";
+/**
+ * Function that generates compiled ajv validation for fast validation of unknown data
+ *
+ * @param name The name of the schema. The outputted compiled validation file will be <name>.js
+ * @param schema The zod schema
+ */
+export const generateValidatorsFromZodSchema = (
+  name: string,
+  schema: ZodType<any, ZodTypeDef, any>,
+  rootDir: string
+): GeneratedFilePath => {
+  const ajv = new Ajv({
+    $data: true,
+    allErrors: true,
+    useDefaults: true,
+    code: {
+      esm: true,
+      source: true,
+    },
+    strict: true,
+  });
+
+  addFormats(ajv);
+  const validationCode = standaloneCode(
+    ajv,
+    ajv.compile(zodToJsonSchema(schema, `${name.toLowerCase()}JsonSchema`))
+  );
+
+  const dir: string = join(rootDir, "generated", "validators");
+  mkdirSync(dir, { recursive: true });
+
+  const generatedFilePath: GeneratedFilePath = join(dir, `${name}.js`);
+
+  writeFileSync(generatedFilePath, validationCode, {
+    flag: "w+",
+  });
+
+  console.log(`${name} validator created`)
+
+  return generatedFilePath;
+};
+
+export const getImportableValidatorFilePathRelativeToGeneratedFolder = (
+  name: string
+) => {
+  return `../validators/${name}`;
+};

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../kit-build/tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./dist"
+  },
+  "exclude": ["**/*.test.ts", "**/*.mock.ts", "dist"],
+  "references": [
+    {
+      "path": "../kit-constants"
+    }
+  ]
+}