@x-dome/joi-to-typescript 4.15.0

package/.yarnrc.yml

@@ -0,0 +1,5 @@
+compressionLevel: mixed
+
+enableGlobalCache: false
+
+nodeLinker: node-modules

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Jono
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,343 @@
+# joi-to-typescript
+
+[![NPM version][npm-image]][npm-url] ![Latest Build](https://github.com/mrjono1/joi-to-typescript/workflows/Node.js%20CI/badge.svg) ![NPM Release Build](https://github.com/mrjono1/joi-to-typescript/workflows/Node.js%20Package/badge.svg) ![GitHub top language](https://img.shields.io/github/languages/top/mrjono1/joi-to-typescript) [![codecov](https://codecov.io/gh/mrjono1/joi-to-typescript/branch/master/graph/badge.svg?token=7UtmWfj5cA)](https://codecov.io/gh/mrjono1/joi-to-typescript)
+[![npm downloads](https://img.shields.io/npm/dm/joi-to-typescript.svg?style=flat-square)](https://npm-stat.com/charts.html?package=joi-to-typescript)
+[![Known Vulnerabilities](https://snyk.io/test/npm/joi-to-typescript/badge.svg)](https://snyk.io/test/npm/joi-to-typescript)
+
+[joi-to-typescript on GitHub](https://github.com/mrjono1/joi-to-typescript)
+
+[npm-image]: https://img.shields.io/npm/v/joi-to-typescript.svg?style=flat
+[npm-url]: https://www.npmjs.com/package/joi-to-typescript
+
+Convert [Joi](https://github.com/sideway/joi) Schemas to TypeScript interfaces
+
+This will allow you to use generate TypeScript interfaces from Joi Schemas giving you confidence the schema and interface match. You no longer have to manually create the same structure again, saving you time and reducing errors.
+
+Works with any TypeScript project and also perfectly with [Hapi](https://github.com/hapijs/hapi) API requests/responses.
+
+For generating Open Api/Swagger this project works with
+
+- [joi-to-swagger](https://github.com/Twipped/joi-to-swagger) using `.meta({className:''})`
+- [hapi-swagger](https://github.com/glennjones/hapi-swagger) using `.label('')`
+
+The use of `.meta({className:'')` is preferred over `.label('')`, because `Joi.label()` is intended to be used for meaningful error message, using it for another purpose makes Joi lose a standard feature, this is especially noticeable for frontend usages of Joi. The choice of the property `className` is because this property is used by joi-to-swagger making this project work with other projects.
+
+## Installation Notes
+
+This package is intended as a development time tool, so it should be installed in the `devDependencies`
+
+```bash
+yarn add joi-to-typescript --dev
+# or
+npm install joi-to-typescript --save-dev
+```
+
+You will also need to install `joi` in the `dependencies`
+
+```bash
+yarn add joi
+# or
+npm install joi
+```
+
+- This has been built for `"joi": "^17"` and will not work for older versions
+- Supported node versions 18, 20
+
+## Suggested Usage
+
+1. Create a Schemas Folder eg. `src/schemas`
+1. Create a interfaces Folder eg. `src/interfaces`
+1. Create Joi Schemas in the Schemas folder with a file name suffix of Schemas eg. `AddressSchema.ts`
+   - The file name suffix ensures that type file and schema file imports are not confusing
+
+## Example
+
+#### Example Project
+
+Explore the [Example Projects](https://github.com/mrjono1/joi-to-typescript/tree/master/examples) for recommended setup, execute `yarn types` to run each one.
+
+#### Example Schema
+
+This example can be found in `src/__tests__/readme`
+
+```typescript
+import Joi from 'joi';
+
+// Input
+export const JobSchema = Joi.object({
+  businessName: Joi.string().required(),
+  jobTitle: Joi.string().required()
+}).meta({ className: 'Job' });
+
+export const WalletSchema = Joi.object({
+  usd: Joi.number().required(),
+  eur: Joi.number().required()
+})
+  .unknown()
+  .meta({ className: 'Wallet', unknownType: 'number' });
+
+export const PersonSchema = Joi.object({
+  firstName: Joi.string().required(),
+  lastName: Joi.string().required().description('Last Name'),
+  job: JobSchema,
+  wallet: WalletSchema
+}).meta({ className: 'Person' });
+
+export const PeopleSchema = Joi.array()
+  .items(PersonSchema)
+  .required()
+  .meta({ className: 'People' })
+  .description('A list of People');
+
+// Output
+/**
+ * This file was automatically generated by joi-to-typescript
+ * Do not modify this file manually
+ */
+
+export interface Job {
+  businessName: string;
+  jobTitle: string;
+}
+
+/**
+ * A list of People
+ */
+export type People = Person[];
+
+export interface Person {
+  firstName: string;
+  job?: Job;
+  /**
+   * Last Name
+   */
+  lastName: string;
+  wallet?: Wallet;
+}
+
+export interface Wallet {
+  /**
+   * Number Property
+   */
+  [x: string]: number;
+  eur: number;
+  usd: number;
+}
+```
+
+##### Points of Interest
+
+- `export const PersonSchema` schema must be exported
+- `export const PersonSchema` includes a suffix of Schema so the schema and interface are not confused when using `import` statements (recommended not required)
+- `.meta({ className: 'Person' });` Sets `interface` name using TypeScript conventions (TitleCase Interface name, camelCase property name)
+- `.meta({ unknownType: 'number' });` assert unknown type to `number`
+
+#### Upgrade Notice
+
+- Version 1 used `.label('Person')` as the way to define the `interface` name, to use this option set `{ useLabelAsInterfaceName: true }`
+
+#### Example Call
+
+```typescript
+import { convertFromDirectory } from 'joi-to-typescript';
+
+convertFromDirectory({
+  schemaDirectory: './src/schemas',
+  typeOutputDirectory: './src/interfaces',
+  debug: true
+});
+
+// or to get an interface as a string. Please note that this method is limited
+import { convertSchema } from 'joi-to-typescript';
+const resultingInterface = convertSchema({}, JobSchema);
+resultingInterface?.content = // the interface as a string
+```
+
+## Settings
+
+```typescript
+export interface Settings {
+  /**
+   * The input/schema directory
+   * Directory must exist
+   */
+  schemaDirectory: string;
+  /**
+   * The output/type directory
+   * Will also attempt to create this directory
+   */
+  typeOutputDirectory: string;
+  /**
+   * Use .label('InterfaceName') instead of .meta({className:'InterfaceName'}) for interface names
+   */
+  useLabelAsInterfaceName: boolean;
+  /**
+   * If defined, when a schema name ends with "schema", replaces the ending in the generated type by default
+   * with this string.
+   * E.g. when this setting is "Interface", a `TestSchema` object generates a `TestInterface` type
+   */
+  defaultInterfaceSuffix?: string;
+  /**
+   * Should interface properties be defaulted to optional or required
+   * @default false
+   */
+  defaultToRequired: boolean;
+  /**
+   * What schema file name suffix will be removed when creating the interface file name
+   * @default "Schema"
+   * This ensures that an interface and Schema with the file name are not confused
+   */
+  schemaFileSuffix: string;
+  /**
+   * If provided, appends this suffix to the generated interface filenames
+   * @default ""
+   */
+  interfaceFileSuffix: string;
+  /**
+   * If `true` the console will include more information
+   * @default false
+   */
+  debug: boolean;
+  /**
+   * File Header content for generated files
+   */
+  fileHeader: string;
+  /**
+   * If true will sort properties on interface by name
+   * @default true
+   */
+  sortPropertiesByName: boolean;
+  /**
+   * If true will not output to subDirectories in output/interface directory. It will flatten the structure.
+   */
+  flattenTree: boolean;
+  /**
+   * If true will only read the files in the root directory of the input/schema directory. Will not parse through sub-directories.
+   */
+  rootDirectoryOnly: boolean;
+  /**
+   * If true will write all exports *'s to root index.ts in output/interface directory.
+   */
+  indexAllToRoot: boolean;
+  /**
+   * Comment every interface and property even with just a duplicate of the interface and property name
+   * @default false
+   */
+  commentEverything: boolean;
+  /**
+   * List of files or folders that should be ignored from conversion. These can either be
+   * filenames (AddressSchema.ts) or filepaths postfixed with a / (addressSchemas/)
+   * @default []
+   */
+  ignoreFiles: string[];
+  /**
+   * The indentation characters
+   * @default '  ' (two spaces)
+   */
+  indentationChacters: string;
+  /**
+   * If set to true, will use double quotes for strings
+   * @default false
+   */
+  doublequoteEscape: boolean;
+  /**
+   * If a field has a default and is optional, consider it as required
+   * @default false
+   */
+  treatDefaultedOptionalAsRequired: boolean;
+  /**
+   * If a field has a default, modify the resulting field to equal
+   * `field: <default> | type` rather than `field: type`
+   * @default false
+   */
+  supplyDefaultsInType: boolean;
+  /**
+   * If a field has a default value, add its stringified representation
+   * to the JsDoc using the @default annotation
+   * @default false
+   */
+  supplyDefaultsInJsDoc: boolean;
+  /**
+   * Filter files you wish to parse
+   * The class `InputFileFilter` contains some default options
+   * @default *.ts files
+   */
+  inputFileFilter: RegExp;
+  /**
+   * If true, skips the creation of index.ts files in the generated interface directories
+   * @default false
+   */
+  omitIndexFiles: boolean
+  /**
+   * If provided, prepends the content returned by the function to the
+   * generated interface/type code (including and JSDoc).
+   */
+  tsContentHeader?: (type: ConvertedType) => string;
+  /**
+   * If provided, appends the content returned by the function to the
+   * generated interface/type code.
+   */
+  tsContentFooter?: (type: ConvertedType) => string;
+  /**
+   * If defined, place every member of a union on a new line
+   */
+  unionNewLine?: boolean;
+  /**
+   * If defined, place every member of a tuple on a new line
+   */
+  tupleNewLine?: boolean;
+}
+```
+
+## Joi Features Supported
+
+- `.meta({className:'InterfaceName'})` - interface Name and in jsDoc
+- `.description('What this interface is for')` - jsdoc
+- `.optional()` - optional properties `?`
+- `.required()` - required properties
+- `.valid(['red', 'green', 'blue'])` - enumerations - `allow` can be used for enumerations but `valid` works better see `_tests_/allow/allow.ts` for more information
+- `.allow('')` - will be ignored on a string
+- `.allow(null)` - will add as an optional type eg `string | null`
+- `.array()`, `.object()`, `.string()`, `.number()`, `.boolean()` - standard Joi schemas
+- `.alternatives()` - try is supported, conditionals would be converted to `any`
+- `.unknown(true)` - will add a property `[x: string]: unknown;` to the interface
+  - Assert `unknown` to some type with a stringified type or a Joi schema, e.g.:
+  ```typescript
+    .meta({ unknownType: 'some-type' })
+  ```
+  ```typescript
+    .meta({ unknownType: Joi.object({ id: Joi.string() }) })`
+  ```
+- `.example()` - jsdoc
+- `.cast()` - currently will honor casting to string and number types, map and set to be added later
+- `.forbidden()` will set the type to `undefined`
+- `.meta({ readonly: true })` to create readonly properties like `readonly property: string;`
+- `.ordered()`
+- And many others
+
+## Contributing
+
+- Raise or comment on an [Issue](https://github.com/mrjono1/joi-to-typescript/issues) with a bug or feature request
+- Contribute code via Raising a [Pull Request](https://github.com/mrjono1/joi-to-typescript/pulls)
+- Start a [Discussion](https://github.com/mrjono1/joi-to-typescript/discussions)
+
+### Recommended Development Environment
+
+Recommended Editor is VS Code, this project is setup with VSCode settings in the `./.vscode` directory to keep development consistent.
+
+Best developed on macOS, Linux, or on Windows via WSL.
+
+Install [nodejs](https://nodejs.org/) via [nvm](https://github.com/nvm-sh/nvm) so you can have multiple versions installed
+
+```bash
+nvm use # using NVM to select node version
+yarn install # using yarn
+yarn test # run local tests
+
+yarn coverage # test coverage report
+yarn lint # lint the code
+```
+
+### Change Log
+
+See [GitHub Releases](https://github.com/mrjono1/joi-to-typescript/releases)

package/SECURITY.md

@@ -0,0 +1,9 @@
+# Security Policy
+
+## Supported Versions
+
+Only the latest version will get security updates
+
+## Reporting a Vulnerability
+
+If a security vulnerability is found please raise an [Issue](https://github.com/mrjono1/joi-to-typescript/issues) to report or a [Pull Request](https://github.com/mrjono1/joi-to-typescript/pulls) to fix the issue

package/dist/main/analyseSchemaFile.d.ts

@@ -0,0 +1,12 @@
+import { AnySchema } from 'joi';
+import { Settings, ConvertedType, GenerateTypeFile } from './types';
+export declare function convertSchemaInternal(settings: Settings, joi: AnySchema, exportedName?: string, rootSchema?: boolean): ConvertedType | undefined;
+/**
+ * Analyse a schema file
+ *
+ * @param settings - Settings
+ * @param schemaFileName - Schema File Name
+ * @returns Schema analysis results
+ */
+export declare function analyseSchemaFile(settings: Settings, schemaFileName: string): Promise<undefined | GenerateTypeFile>;
+//# sourceMappingURL=analyseSchemaFile.d.ts.map

package/dist/main/analyseSchemaFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyseSchemaFile.d.ts","sourceRoot":"","sources":["../../src/analyseSchemaFile.ts"],"names":[],"mappings":"AAAA,OAAY,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;AAGrC,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAMpE,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,QAAQ,EAClB,GAAG,EAAE,SAAS,EACd,YAAY,CAAC,EAAE,MAAM,EACrB,UAAU,CAAC,EAAE,OAAO,GACnB,aAAa,GAAG,SAAS,CAmD3B;AACD;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,QAAQ,EAAE,QAAQ,EAClB,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,SAAS,GAAG,gBAAgB,CAAC,CAwEvC"}

package/dist/main/analyseSchemaFile.js

@@ -0,0 +1,149 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertSchemaInternal = convertSchemaInternal;
+exports.analyseSchemaFile = analyseSchemaFile;
+const joi_1 = __importDefault(require("joi"));
+const path_1 = __importDefault(require("path"));
+const write_1 = require("./write");
+const parse_1 = require("./parse");
+const joiUtils_1 = require("./joiUtils");
+function convertSchemaInternal(settings, joi, exportedName, rootSchema) {
+    const details = joi.describe();
+    const interfaceOrTypeName = (0, joiUtils_1.getInterfaceOrTypeName)(settings, details) || exportedName;
+    if (!interfaceOrTypeName) {
+        if (settings.useLabelAsInterfaceName) {
+            throw new Error(`At least one "object" does not have .label(''). Details: ${JSON.stringify(details)}`);
+        }
+        else {
+            throw new Error(`At least one "object" does not have .meta({className:''}). Details: ${JSON.stringify(details)}`);
+        }
+    }
+    if (settings.debug && interfaceOrTypeName.toLowerCase().endsWith('schema')) {
+        if (settings.useLabelAsInterfaceName) {
+            // eslint-disable-next-line no-console
+            console.debug(`It is recommended you update the Joi Schema '${interfaceOrTypeName}' similar to: ${interfaceOrTypeName} = Joi.object().label('${interfaceOrTypeName.replace('Schema', '')}')`);
+        }
+        else {
+            // eslint-disable-next-line no-console
+            console.debug(`It is recommended you update the Joi Schema '${interfaceOrTypeName}' similar to: ${interfaceOrTypeName} = Joi.object().meta({className:'${interfaceOrTypeName.replace('Schema', '')}'})`);
+        }
+    }
+    (0, joiUtils_1.ensureInterfaceorTypeName)(settings, details, interfaceOrTypeName);
+    const parsedSchema = (0, parse_1.parseSchema)(details, settings, false, undefined, rootSchema);
+    if (parsedSchema) {
+        const customTypes = (0, parse_1.getAllCustomTypes)(parsedSchema);
+        const content = (0, parse_1.typeContentToTs)(settings, parsedSchema, true);
+        return {
+            schema: joi,
+            interfaceOrTypeName,
+            customTypes,
+            content
+        };
+    }
+    // The only type that could return this is alternatives
+    // see parseAlternatives for why this is ignored
+    /* istanbul ignore next */
+    return undefined;
+}
+/**
+ * Analyse a schema file
+ *
+ * @param settings - Settings
+ * @param schemaFileName - Schema File Name
+ * @returns Schema analysis results
+ */
+async function analyseSchemaFile(settings, schemaFileName) {
+    const allConvertedTypes = [];
+    const fullFilePath = path_1.default.resolve(path_1.default.join(settings.schemaDirectory, schemaFileName));
+    const schemaFile = await Promise.resolve(`${fullFilePath}`).then(s => __importStar(require(s)));
+    // Create Type File Name
+    const typeFileName = (0, write_1.getTypeFileNameFromSchema)(schemaFileName, settings);
+    const fullOutputFilePath = path_1.default.join(settings.typeOutputDirectory, typeFileName);
+    for (const exportedName in schemaFile) {
+        const joiSchema = schemaFile[exportedName];
+        if (!joi_1.default.isSchema(joiSchema)) {
+            continue;
+        }
+        const convertedType = convertSchemaInternal(settings, joiSchema, exportedName, true);
+        if (convertedType) {
+            allConvertedTypes.push({ ...convertedType, location: fullOutputFilePath });
+        }
+    }
+    if (allConvertedTypes.length === 0) {
+        if (settings.debug) {
+            // eslint-disable-next-line no-console
+            console.debug(`${schemaFileName} - Skipped - no Joi Schemas found`);
+        }
+        return;
+    }
+    if (settings.debug) {
+        // eslint-disable-next-line no-console
+        console.debug(`${schemaFileName} - Processing`);
+    }
+    // Clean up type list
+    // Sort Types
+    const typesToBeWritten = allConvertedTypes.sort((interface1, interface2) => 0 - (interface1.interfaceOrTypeName > interface2.interfaceOrTypeName ? -1 : 1));
+    // Write types
+    const typeContent = typesToBeWritten.map(typeToBeWritten => {
+        const content = typeToBeWritten.content;
+        return [
+            ...(settings.tsContentHeader ? [settings.tsContentHeader(typeToBeWritten)] : []),
+            content,
+            ...(settings.tsContentFooter ? [settings.tsContentFooter(typeToBeWritten)] : [])
+        ].join('\n');
+    });
+    // Get imports for the current file
+    const allExternalTypes = [];
+    const allCurrentFileTypeNames = typesToBeWritten.map(typeToBeWritten => typeToBeWritten.interfaceOrTypeName);
+    for (const typeToBeWritten of typesToBeWritten) {
+        for (const customType of typeToBeWritten.customTypes) {
+            if (!allCurrentFileTypeNames.includes(customType) && !allExternalTypes.includes(typeToBeWritten)) {
+                allExternalTypes.push(typeToBeWritten);
+            }
+        }
+    }
+    const fileContent = `${typeContent.join('\n\n').concat('\n')}`;
+    return {
+        externalTypes: allExternalTypes,
+        internalTypes: typesToBeWritten,
+        fileContent,
+        typeFileName,
+        typeFileLocation: settings.typeOutputDirectory
+    };
+}

package/dist/main/convertFilesInDirectory.d.ts

@@ -0,0 +1,7 @@
+import { Settings, GenerateTypeFile, GenerateTypesDir } from './types';
+/**
+ * Create types from schemas from a directory
+ * @param settings Settings
+ */
+export declare function convertFilesInDirectory(appSettings: Settings, ogTypeOutputDir: string, fileTypesToExport?: GenerateTypeFile[]): Promise<GenerateTypesDir>;
+//# sourceMappingURL=convertFilesInDirectory.d.ts.map

package/dist/main/convertFilesInDirectory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convertFilesInDirectory.d.ts","sourceRoot":"","sources":["../../src/convertFilesInDirectory.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAIvE;;;GAGG;AACH,wBAAsB,uBAAuB,CAC3C,WAAW,EAAE,QAAQ,EACrB,eAAe,EAAE,MAAM,EACvB,iBAAiB,GAAE,gBAAgB,EAAO,GACzC,OAAO,CAAC,gBAAgB,CAAC,CAgF3B"}

package/dist/main/convertFilesInDirectory.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertFilesInDirectory = convertFilesInDirectory;
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const write_1 = require("./write");
+const analyseSchemaFile_1 = require("./analyseSchemaFile");
+/**
+ * Create types from schemas from a directory
+ * @param settings Settings
+ */
+async function convertFilesInDirectory(appSettings, ogTypeOutputDir, fileTypesToExport = []) {
+    // Check and resolve directories
+    const resolvedSchemaDirectory = path_1.default.resolve(appSettings.schemaDirectory);
+    if (!(0, fs_1.existsSync)(resolvedSchemaDirectory)) {
+        throw new Error(`schemaDirectory "${resolvedSchemaDirectory}" does not exist`);
+    }
+    const resolvedTypeOutputDirectory = path_1.default.resolve(appSettings.typeOutputDirectory);
+    if (!(0, fs_1.existsSync)(resolvedTypeOutputDirectory)) {
+        (0, fs_1.mkdirSync)(resolvedTypeOutputDirectory, { recursive: true });
+    }
+    let fileNamesToExport = [];
+    const currentDirFileTypesToExport = fileTypesToExport;
+    // Load files and get all types
+    const files = (0, fs_1.readdirSync)(resolvedSchemaDirectory);
+    for (const schemaFileName of files) {
+        const subDirectoryPath = path_1.default.join(resolvedSchemaDirectory, schemaFileName);
+        if (!appSettings.rootDirectoryOnly && (0, fs_1.lstatSync)(subDirectoryPath).isDirectory()) {
+            if (appSettings.ignoreFiles.includes(`${schemaFileName}/`)) {
+                if (appSettings.debug) {
+                    // eslint-disable-next-line no-console
+                    console.debug(`Skipping ${subDirectoryPath} because it's in your ignore files list`);
+                }
+                continue;
+            }
+            const typeOutputDirectory = appSettings.flattenTree
+                ? resolvedTypeOutputDirectory
+                : path_1.default.join(resolvedTypeOutputDirectory, schemaFileName);
+            const thisDirsFileNamesToExport = await convertFilesInDirectory({
+                ...appSettings,
+                schemaDirectory: subDirectoryPath,
+                typeOutputDirectory
+            }, ogTypeOutputDir, currentDirFileTypesToExport);
+            if (appSettings.indexAllToRoot || appSettings.flattenTree) {
+                fileNamesToExport = fileNamesToExport.concat(thisDirsFileNamesToExport.typeFileNames);
+            }
+        }
+        else {
+            if (!appSettings.inputFileFilter.test(schemaFileName)) {
+                if (appSettings.debug) {
+                    // eslint-disable-next-line no-console
+                    console.debug(`Skipping ${schemaFileName} because it's excluded via inputFileFilter`);
+                }
+                continue;
+            }
+            if (appSettings.ignoreFiles.includes(schemaFileName)) {
+                if (appSettings.debug) {
+                    // eslint-disable-next-line no-console
+                    console.debug(`Skipping ${schemaFileName} because it's in your ignore files list`);
+                }
+                continue;
+            }
+            const exportType = await (0, analyseSchemaFile_1.analyseSchemaFile)(appSettings, schemaFileName);
+            if (exportType) {
+                let dirTypeFileName = exportType.typeFileName;
+                if (appSettings.indexAllToRoot) {
+                    const findIndexEnd = resolvedTypeOutputDirectory.indexOf(ogTypeOutputDir) + ogTypeOutputDir.length + 1;
+                    dirTypeFileName = path_1.default.join(resolvedTypeOutputDirectory.substring(findIndexEnd), (0, write_1.getTypeFileNameFromSchema)(schemaFileName, appSettings));
+                }
+                fileNamesToExport.push(dirTypeFileName);
+                currentDirFileTypesToExport.push(exportType);
+            }
+        }
+    }
+    if (!appSettings.omitIndexFiles && (!appSettings.indexAllToRoot && !appSettings.flattenTree)) {
+        // Write index.ts
+        (0, write_1.writeIndexFile)(appSettings, fileNamesToExport);
+    }
+    return { typeFileNames: fileNamesToExport, types: currentDirFileTypesToExport };
+}

package/dist/main/index.d.ts

@@ -0,0 +1,12 @@
+import { AnySchema } from 'joi';
+import { Settings, ConvertedType } from './types';
+export { Settings };
+export declare function convertSchema(settings: Partial<Settings>, joi: AnySchema, exportedName?: string, root?: boolean): ConvertedType | undefined;
+/**
+ * Create types from schemas from a directory
+ *
+ * @param settings - Configuration settings
+ * @returns The success or failure of this operation
+ */
+export declare function convertFromDirectory(settings: Partial<Settings>): Promise<boolean>;
+//# sourceMappingURL=index.d.ts.map

package/dist/main/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,KAAK,CAAC;AAGhC,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAmB,MAAM,SAAS,CAAC;AAMnE,OAAO,EAAE,QAAQ,EAAE,CAAC;AAoCpB,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,EAC3B,GAAG,EAAE,SAAS,EACd,YAAY,CAAC,EAAE,MAAM,EACrB,IAAI,CAAC,EAAE,OAAO,GACb,aAAa,GAAG,SAAS,CAG3B;AAED;;;;;GAKG;AACH,wBAAsB,oBAAoB,CAAC,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAoBxF"}