open-index/open-npm huggingface dataset:
npm package: @jerrythomas/dbd
Description: Command line interface for database design and deployment.
Author: Jerry Thomas
Latest version: 2.2.2

# @jerrythomas/dbd

A CLI tool for managing SQL database schemas. Apply individual DDL scripts to databases, load staging data, export data, and generate DBML documentation for [dbdocs.io](https://dbdocs.io).

## Installation

```bash
npm i --global @jerrythomas/dbd
```

## Usage

### Folder Structure

Individual DDL scripts are expected to be placed under folders with names of the database object types. Subfolders are used to specify the schema names. Files are expected to have the same name as the object.

> Note: The CLI relies on dependencies mentioned in a YAML file (`design.yaml`) to execute scripts in sequence.

### Commands

| Command      | Action                               |
| ------------ | ------------------------------------ |
| dbd init     | Create an example repo               |
| dbd inspect  | Inspect and report issues            |
| dbd combine  | Combine all into single script       |
| dbd apply    | Apply DDL and run pending migrations |
| dbd snapshot | Capture schema snapshot + migration  |
| dbd migrate  | Apply pending migrations standalone  |
| dbd import   | Load seed/staging files              |
| dbd export   | Export tables/views                  |
| dbd reset    | Drop schemas to bare state           |
| dbd grants   | Apply PostgREST schema grants        |
| dbd dbml     | Generate DBML files                  |
| dbd graph    | Output dependency graph as JSON      |

### Options

```
-c, --config       Provide path to custom config (default: design.yaml)
-d, --database     Database URL (default: $DATABASE_URL)
-e, --environment  Environment to load data (default: development)
-p, --preview      Preview the action
```

## Related Packages

| Package                                                                                              | Description                     |
| ---------------------------------------------------------------------------------------------------- | ------------------------------- |
| [@jerrythomas/dbd-db](https://www.npmjs.com/package/@jerrythomas/dbd-db)                             | Database operations abstraction |
| [@jerrythomas/dbd-dbml](https://www.npmjs.com/package/@jerrythomas/dbd-dbml)                         | DBML conversion & documentation |
| [@jerrythomas/dbd-postgres-adapter](https://www.npmjs.com/package/@jerrythomas/dbd-postgres-adapter) | PostgreSQL adapter              |

## License

[MIT](LICENSE)
npm package: @jerrythomas/dbd-db
Description: Database operations abstraction layer for DBD.
Author: Jerry Thomas
Latest version: 2.2.2

# @jerrythomas/dbd-db

Database operations abstraction layer for [dbd](https://www.npmjs.com/package/@jerrythomas/dbd). Provides entity processing, dependency resolution, and a database adapter factory.

## Features

- Base database adapter with common operations (apply, import, export)
- Entity processing — create entities from files, schemas, roles, extensions
- DDL generation and script combination
- Dependency graph builder with cycle detection and topological sorting
- Adapter factory with plugin registration

## Usage

```js
import { createAdapter, entityFromFile, sortByDependencies } from '@jerrythomas/dbd-db'

// Create a database adapter
const adapter = await createAdapter('postgres', connectionString, options)

// Process entities and resolve dependencies
const entity = entityFromFile('tables', 'public', 'users.sql')
const sorted = sortByDependencies(entities)
```

## API

### Adapter Factory

- `createAdapter(dialect, connectionString, options)` — create a dialect-specific adapter
- `registerAdapter(dialect, factory)` — register a custom adapter
- `getAdapterInfo()` — list registered adapters

### Entity Processing

- `entityFromFile(type, schema, file)` — create entity from a DDL file
- `entityFromSchemaName(schema)` — create schema entity
- `entityFromRoleName(role)` — create role entity
- `ddlFromEntity(entity)` — generate DDL from entity
- `combineEntityScripts(entities)` — combine into single script
- `validateEntity(entity)` / `getValidEntities(entities)` / `getInvalidEntities(entities)`

### Dependency Resolution

- `buildDependencyGraph(entities)` — build directed dependency graph
- `findCycles(graph)` — detect circular dependencies
- `sortByDependencies(entities)` — topological sort
- `groupByDependencyLevel(entities)` — group for parallel execution

## License

MIT
npm package: @jerrythomas/dbd-dbml
Description: DBML conversion and publishing utilities for DBD.
Author: Jerry Thomas
Latest version: 2.2.2

# @jerrythomas/dbd-dbml

DBML conversion and publishing utilities for [dbd](https://www.npmjs.com/package/@jerrythomas/dbd). Converts DDL scripts into [DBML](https://dbml.dbdiagram.io/) format for use with [dbdocs.io](https://dbdocs.io).

## Features

- Convert DDL to DBML via [@dbml/core](https://www.npmjs.com/package/@dbml/core)
- Schema-qualified table name handling
- DDL cleanup (comments, indexes, unsupported statements)
- Project block generation for dbdocs

## Usage

```js
import { generateDBML, convertToDBML } from '@jerrythomas/dbd-dbml'

// Generate DBML from a collection of entities
const dbml = generateDBML(entities, projectName)

// Convert a single DDL string
const result = convertToDBML(ddlString)
```

## API

- `generateDBML(entities, projectName)` — generate full DBML document from entities
- `convertToDBML(ddl)` — convert DDL string to DBML
- `cleanupDDLForDBML(ddl)` — strip unsupported SQL for DBML conversion
- `buildProjectBlock(name)` — generate DBML project block
- `qualifyTableNames(ddl, schema)` — add schema prefixes to table names
- `buildTableLookup(entities)` / `buildTableReplacements(lookup)` / `applyTableReplacements(dbml, replacements)`

## License

MIT
npm package: @jerrythomas/dbd-postgres-adapter
Description: PostgreSQL adapter for DBD database operations.
Author: Jerry Thomas
Latest version: 2.2.2

# @jerrythomas/dbd-postgres-adapter

PostgreSQL adapter for [dbd](https://www.npmjs.com/package/@jerrythomas/dbd). Provides SQL parsing, reference classification, and database operations via `psql`.

## Features

- PostgreSQL adapter using `psql` CLI for apply, import, and export
- SQL parser using [pgsql-parser](https://www.npmjs.com/package/pgsql-parser) (PostgreSQL C parser via WASM)
- Schema extraction — tables, views, procedures, indexes, dependencies
- Reference classifier — distinguishes internal, PostgreSQL built-in, ANSI SQL, and extension references

## Usage

```js
import { createAdapter } from '@jerrythomas/dbd-postgres-adapter'

const adapter = createAdapter('postgres://localhost:5432/mydb', { verbose: true })
await adapter.apply(entity)
await adapter.importData(entity)
await adapter.exportData(entity)
```

### Parser API

```js
import { parseSchema, extractTables, extractDependencies } from '@jerrythomas/dbd-postgres-adapter'

const schema = parseSchema(sqlString)
const tables = extractTables(sqlString)
const deps = extractDependencies(sqlString)
```

### Reference Classifier

```js
import { isInternal, isPostgres, isExtension } from '@jerrythomas/dbd-postgres-adapter'

isInternal('public.users') // true if defined in project
isPostgres('pg_catalog') // true
isExtension('uuid_generate_v4') // true if known extension function
```

## License

MIT
npm package: @jerrythomas/eslint-config-svelte
Description: > [ESLint](https://eslint.org) config for svelte projects.
Latest version: 1.0.3

# `@jerrythomas/eslint-config-svelte`

> [ESLint](https://eslint.org) config for svelte projects.

## Usage

Install

```bash
pnpm add --dev @jerrythomas/eslint-config-svelte
```

`.eslintrc`

```json
{
  "extends": "@jerrythomas/eslint-config-svelte",
  "root": true
}
```
npm package: @jerrywithaz/react-conditionals
Description: Declaritive conditional statements for React.
Author: Zerry Hogan
Latest version: 1.0.8

# React Conditionals

Decalrative and performant conditional statements for React.

## Components

### If

The most basic component is the `If` component. The `If` component can be used in isolation to render a component if a condition is truthy.

#### Using Boolean Conditions

```tsx
import { If } from '@jerrywithaz/react-conditionals';

const Component = () => {
    return (
        <If condition={userIsActive}>
            <UserIsActiveHeader/>
        </If>
    );
}
```

#### Using With Objects

The `If` component accepts a data prop that can be used in combination with the
`render` prop. Using `data` instead of `condition` is useful for ensuring that
some set of data is available before rendering your component.

```tsx
import { If } from '@jerrywithaz/react-conditionals';

const Component = () => {
    return (
        <If data={userData} render={(userData) => (
            <User data={userData}/>
        )}/>
    );
}
```

### Control Flow

The `ControlFlow` component is for managing the control flow of a series of control statements i.e. if, elseif and else.
In order to use `ElseIf` or `Else` you must wrap them in a `ControlFlow` for them to work correctly.

```tsx
import { ControlFlow, If, ElseIf, Else } from '@jerrywithaz/react-conditionals';

const NumberDisplayer = () => (
    <ControlFlow>
        <If condition={number == 0}>
            <div>Number was 0</div>
        </If>
        <ElseIf condition={number > 0 && number <= 30}>
            <div>Number was greater than 0 and less than or equal to 30</div>
        </ElseIf>
        <ElseIf condition={number > 30 && number <= 60}>
            <div>Number was greater than 30 and less than or equal to 60</div>
        </ElseIf>
        <ElseIf condition={number > 60 && number < 100}>
            <div>Number was greater than 60 and less than 100</div>
        </ElseIf>
        <Else>
            <div>Number was 100.</div>
        </Else>
    </ControlFlow>
);
```
npm package: @jerrywn/chatgpt-api
Description: A simple, lightweight, configurable ChatGPT api by nodejs
Author: JerryWn
Latest version: 1.0.5

# chatgpt-api

## Example

```javascript
import ChatGPT from "@jerrywn/chatgpt-api"

const client = new ChatGPT({
  openaiApiKey: process.env.OPENAI_API_KEY || "",
})

const conv01 = client.newConversation()
const response01 = await client.sendMessage("who are you?")
console.log(response01)

const conv02 = client.newConversation()
const response02 = await client.sendMessage("where are you from?")
console.log(response02)

client.useConversation(conv01)
const response03 = await client.sendMessage("whats my previous question?")
console.log(response03)
```

output

```output
I am an AI language model designed to assist and provide helpful responses to users. How may I assist you?
As an AI language model developed by OpenAI, I don't have a physical presence, so I'm not really "from" anywhere. However, OpenAI is a research organization based in San Francisco, California.
Your previous question was "who are you?"
```

## Usage

`npm install @jerrywn/chatgpt-api`

`import ChatGPT from "@jerrywn/chatgpt-api"`

## API

### `new ChatGPT()`: object

### params

`openaiApiKey`: string

your openai api key from [openai](https://platform.openai.com/account/api-keys), required

`model`: string

model name, optional, default: "gpt-3.5-turbo"

`temperature`: string or number

model temperature, see [openai doc](https://platform.openai.com/docs/api-reference/chat/create#chat/create-temperature), optional, default: 0.7

`maxTokens`: string or number

model max_tokens, see [openai doc](https://platform.openai.com/docs/api-reference/chat/create#chat/create-max_tokens), optional, default: 256

`prompt`: string

model's first system message, see [openai doc](https://platform.openai.com/docs/guides/chat/introduction), optional, default: "You are a helpful assistant"

### functions

#### `newConversation()`: string

> create a new conversation, represented by uuid

params:

- none

return:

- the conversation's uuid

---

#### `useConversation(conversation)`

> choice which conversation to send message

params:

- `conversation`: string
  - the conversation id returned by `newConversation()`

return:

- none

---

#### `sendMessage(message)`

params:

- `message`: string

  - the message send to chatgpt

return: string

- reply message by chatgpt
npm package: @jerrywn/chatgpt-server
Description: A chatgpt server by express framework
Author: JerryWn
Latest version: 1.0.5

# chatgpt-server

## Example

```javascript
const response01 = await fetch("http://localhost:3000", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    message: "How are you?",
  }),
})
const data = await response01.json()
const id = data.id
console.log(data)

const response02 = await fetch("http://localhost:3000", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    message: "where are you from?",
  }),
})

console.log(await response02.json())

const response03 = await fetch("http://localhost:3000", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    id,
    message: "whats my previous question",
  }),
})
console.log(await response03.json())
```

output

```text
{
  id: '4effed08-5cbf-403a-ac2f-ac10968205b9',
  message: "As an AI language model, I don't have feelings, but I'm operational and ready to help you! How can I assist you today?"
}
{
  id: '8930eeaa-4570-46ed-a919-1e8535c4f229',
  message: "I don't have a physical origin as I am a virtual assistant powered by AI technology. I was created by OpenAI and am available to assist and interact with users online."
}
{
  id: '4effed08-5cbf-403a-ac2f-ac10968205b9',
  message: 'Your previous question was "How are you?"'
}
```

## Usage

`npm install @jerrywn/chatgpt-server -g`

`chatgpt-server --api-key=<OPENAI_API_KEY>`

## Request

```text
{
    "id": "" // Optional, the converastion id to use
    "message": "" // message send to chatgpt
}
```

## Response

```text
{
    "id": "" // the convesation id in this message
    "message": "" // the chatgpt's reply message
}
```
npm package: @jerseygooner/html-to-rtf
Description: Fork of 'html-to-rtf'
Author: Nijay Patel
Latest version: 1.0.4

# HTML To RTF (Browser and Server)
>This project convert html to rtf format in the Browser (v2.0.0+) and the server with NodeJS.

## Installation
```
$ npm install html-to-rtf
```

## Changelog
```
* Encoding string correctly (v2.0.1)
* Setting correct space and fix some insecure dependencies (v2.0.4)
* Improving better control of spaces (v2.1.0)
```

## Starting in the Browser
```html
<html>
    <head>
      <title>Teste HTML TO RTF</title>
      <script src="./node_modules/html-to-rtf/app/browser/bundle.js"></script>
      <script type="text/javascript">
        window.onload = function() {
            const html =`<p style="color:#333;" align="center">text of p<b>start b <i>italic with bold</i>final text of b</b><i>italic<i>final text of p </p>`;

            document.getElementById('html').innerHTML = html;
            document.getElementById('rtf').innerHTML = htmlToRtf(html);
        }
      </script>

      <link rel="stylesheet" href="./node_modules/html-to-rtf/app/browser/style.css">
    </head>
    <body>
        <h1>HTML To RTF Example:</h1>
        <div class="container">
            <h2>HTML</h2>
            <textarea id="html" readonly></textarea>
        </div>

        <div class="container">
            <h2>RTF</h2>
            <textarea id="rtf" readonly></textarea>
        </div>
    </body>
  </html>
```
##### Observation:
#
>There is a file example (index.html) in  "./node_modules/html-to-rtf/app/browser/index.html"
#
#
## Starting in the Server
```javascript
var htmlToRtf = require('html-to-rtf');
var html = `
<h1>Title <span style="color:rgb(255,0,0);">with</span> tag h1<h1>
<div>
	<p style="color:#333; margin:5px;" class="test" align="center">
	    text of paragraph <b>text with bold <i>text with italic and bold</i></b><i>text with italic</i>
	</p>
	<p style="color:rgb(255,0,0);" align="right">red paragraph => right with tag</p>
	<p style="color:rgb(0,0,255); text-align:center;">blue paragraph => center with style</p>
	<table>
		<tbody>
			<tr>
                <td><mark>column 1</mark></td>
                <td>column 2</td>
				<td><mark>column 3</mark></td>
				<td>column 4</td>
			</tr>
			<tr>
				<td>content 1</td>
				<td>content 2<br></td>
				<td>content 3<br></td>
				<td>content 4<br></td>
			</tr>
		</tbody>
	</table>
</div>
`
htmlToRtf.saveRtfInFile('<Path>/<FileName>.rtf', htmlToRtf.convertHtmlToRtf(html))
```

>  Now test in your preferred text editor (wordpad, word, libreoffice, ...).
##

##### Important:
#
> You can't copy the output of terminal.
> Save the output at a file.rtf

### Allowed html tags
```html
<b>, <br>, <center>, <div>, <em>, <font>, <h1>, <h2>, <h3>, <h4>,
<h5>, <h6>, <i>, <li>, <mark>, <p>, <ol>, 
, <span>, <sub>, <sup>,
<strong>, <table>, <td>, <th>, <tr>, <u>, <ul>
```
### Allowed style properties

> color(Hex and Rgb), font-size(px), text-align


## Running the tests
```
$ gulp tests
```

## Author

> * **Ozires R.S.O.F**

## License
This project is licensed under the MIT License
npm package: @jersmart/automapper-core
Description: AutoMapper TypeScript Core
Author: Chau Tran
Latest version: 0.0.0

# @jersmart/automapper-core

This is the core package that will handle mapping configurations and mapping operations.

## Installation

```sh
npm i @jersmart/automapper-core
```

or with `yarn`

```sh
yarn add @jersmart/automapper-core
```

## Usage

`@jersmart/automapper-core` exposes `createMapper()` method to create a `Mapper` object with a accompany `MappingStrategy` (read more
about [Strategies](#Strategies))

`createMapper` accepts a `CreateMapperOptions` object with the following shape:

```ts
export interface CreateMapperOptions {
    strategyInitializer: MappingStrategyInitializer<MetadataIdentifier>;
    errorHandler?: ErrorHandler;
    namingConventions?: NamingConventionInput;
}
```

Read more about usage on [documentation site](https://automapperts.netlify.app/docs/api/create-mapper)

## Strategies

A given Mapper is accompanied by a Strategy by providing `strategyInitializer` when using `createMapper()`.

A Strategy will be responsible for:

-   Discover metadata (eg: `classes` uses `@AutoMap()` decorator to discover the metadata of the properties on the Classes)
-   Retrieve metadata: how the metadata should be retrieved from the discovery phase (eg: `classes` discovers and stores the metadata to `Reflect`, retrieve metadata simply gets them from `Reflect`)
-   Apply metadata: how the metadata is applied to the Model

`@automapper` provides the following official strategies:

-   `@jersmart/automapper-classes`: Work with TS/ES6 classes.
-   `@jersmart/automapper-pojos`: Work with Interfaces/Types along with POJOs. In projects that do not make use of Class, `pojos`
    can be used instead.
-   `@jersmart/automapper-mikro`: Work together with TS/ES6 classes along with [MikroORM](https://github.com/mikro-orm/mikro-orm)
-   `@jersmart/automapper-sequelize`: Work together with TS/ES6 classes along with [Sequelize](https://github.com/sequelize/sequelize)
npm package: @jersmart/automapper-mikro
Description: AutoMapper TypeScript MikroORM strategy
Author: Chau Tran
Latest version: 0.0.0

# mikro

This library was generated with [Nx](https://nx.dev).

## Building

Run `nx build mikro` to build the library.

## Running unit tests

Run `nx test mikro` to execute the unit tests via [Jest](https://jestjs.io).
npm package: @jersmart/automapper-nestjs
Description: AutoMapper TypeScript NestJS integration
Author: Chau Tran
Latest version: 0.0.0

# @jersmart/automapper-nestjs

This is a NestJS module to integrate `@automapper` with NestJS.

## Installation

```sh
npm i @jersmart/automapper-nestjs
```

or with `yarn`:

```sh
yarn add @jersmart/automapper-nestjs
```

#### `peerDependencies`

`@jersmart/automapper-nestjs` depends on `@jersmart/automapper-core`

```sh
npm i @jersmart/automapper-core
```

or with `yarn`:

```sh
yarn add @jersmart/automapper-core
```

## Usage

Call `AutomapperModule.forRoot()` and provide some options to initialize the `Mapper` object(s).

```ts
// Single Mapper
@Module({
    imports: [
        AutomapperModule.forRoot({
            strategyInitializer: classes(),
        }),
    ],
})
export class AppModule {}

// Multiple Mappers
@Module({
    imports: [
        AutomapperModule.forRoot(
            [
                {
                    name: 'classes',
                    strategyInitializer: classes(),
                },
                {
                    name: 'pojos',
                    strategyInitializer: pojos(),
                },
            ],
            {
                /*  globalErrorHandler: ErrorHandler */
                /*  globalNamingConventions: NamingConvention | {source, destination} */
            }
        ),
    ],
})
export class AppModule {}
```

`AutomapperModule` is a `Global` module so when `Mapper` object(s) are initialized, they're available across the application.

Read more about this on the [documentation site](https://automapperts.netlify.app/docs/nestjs)
npm package: @jersmart/automapper-pojos
Description: AutoMapper TypeScript POJOs plugin
Author: Chau Tran
Latest version: 0.0.0

# @jersmart/automapper-pojos

This is the official strategy from `@automapper` to work with Interfaces/Types along with Plain Objects

## Installation

```sh
npm i @jersmart/automapper-pojos
```

or with `yarn`:

```sh
yarn add @jersmart/automapper-pojos
```

#### `peerDependencies`

`@jersmart/automapper-pojos` depends on `@jersmart/automapper-core`

```sh
npm i @jersmart/automapper-core
```

or with `yarn`:

```sh
yarn add @jersmart/automapper-core
```

## Usage

`@jersmart/automapper-pojos` provides `pojos` as a `MappingStrategyInitializer`. Pass `pojos()` to `createMapper` to create a `Mapper`
that uses `pojos` strategy.

```ts
import { pojos, PojosMetadataMap } from '@jersmart/automapper-pojos';
import { createMapper, createMap, forMember, mapFrom } from '@jersmart/automapper-core';

const mapper = createMapper({
  ...,
  strategyInitializer: pojos()
});

interface User {
    firstName: string;
    lastName: string;
}

interface UserDto {
    firstName: string;
    lastName: string;
    fullName: string;
}

PojosMetadataMap.create<User>('SomeTokenForUser', {
    firstName: String,
    lastName: String
});

PojosMetadataMap.create<UserDto>('SomeTokenForUserDto', {
  firstName: String,
  lastName: String,
  fullName: String
});

createMap<User, UserDto>(
    mapper,
    'SomeTokenForUser',
    'SomeTokenForUserDto',
    forMember(
        d => d.fullName,
        mapFrom(s => s.firstName + ' ' + s.lastName)
    )
);
mapper.map<User, UserDto>(
    {firstName: 'Auto', lastName: 'Mapper'},
    'SomeTokenForUser',
    'SomeTokenForUserDto'
);
// { firstName: 'Auto', lastName: 'Mapper', fullName: 'Auto Mapper' }
```

Read more about this strategy on [pojos documentation](https://automapperts.netlify.app/docs/plugins-system/introduce-to-pojos)
npm package: @jersmart/automapper-sequelize
Description: AutoMapper TypeScript Sequelize strategy
Author: Chau Tran
Latest version: 0.0.0

# sequelize

This library was generated with [Nx](https://nx.dev).

## Building

Run `nx build sequelize` to build the library.

## Running unit tests

Run `nx test sequelize` to execute the unit tests via [Jest](https://jestjs.io).
npm package: @jersmart/swagger-jsdoc
Description: Generates swagger doc based on JSDoc
Author: https://github.com/jersmart/swagger-jsdoc/graphs/contributors
Latest version: 6.1.2

# swagger-jsdoc

This library reads your [JSDoc](https://jsdoc.app/)-annotated source code and generates an [OpenAPI (Swagger) specification](https://swagger.io/specification/).

[![npm Downloads](https://img.shields.io/npm/dm/swagger-jsdoc.svg)](https://www.npmjs.com/package/swagger-jsdoc)
![CI](https://github.com/Surnet/swagger-jsdoc/workflows/CI/badge.svg)

## Getting started

Imagine having API files like these:

```javascript
/**
 * @openapi
 * /:
 *   get:
 *     description: Welcome to swagger-jsdoc!
 *     responses:
 *       200:
 *         description: Returns a mysterious string.
 */
app.get('/', (req, res) => {
  res.send('Hello World!');
});
```

The library will take the contents of `@openapi` (or `@swagger`) with the following configuration:

```javascript
const swaggerJsdoc = require('swagger-jsdoc');

const options = {
  definition: {
    openapi: '3.0.0',
    info: {
      title: 'Hello World',
      version: '1.0.0',
    },
  },
  apis: ['./src/routes*.js'], // files containing annotations as above
};

const openapiSpecification = swaggerJsdoc(options);
```

The resulting `openapiSpecification` will be a [swagger tools](https://swagger.io/tools/)-compatible (and validated) specification.

![swagger-jsdoc example screenshot](./docs/screenshot.png)

## System requirements

- Node.js 12.x or higher

You are viewing `swagger-jsdoc` v6 which is published in CommonJS module system.

## Installation

```bash
npm install swagger-jsdoc --save
```

Or

```bash
yarn add swagger-jsdoc
```

## Supported specifications

- OpenAPI 3.x
- Swagger 2
- AsyncAPI 2.0

## Validation of swagger docs

By default `swagger-jsdoc` tries to parse all docs to it's best capabilities. If you'd like to you can instruct an Error to be thrown instead if validation failed by setting the options flag `failOnErrors` to `true`. This is for instance useful if you want to verify that your swagger docs validate using a unit test.

```javascript
const swaggerJsdoc = require('swagger-jsdoc');

const options = {
  failOnErrors: true, // Whether or not to throw when parsing errors. Defaults to false.
  definition: {
    openapi: '3.0.0',
    info: {
      title: 'Hello World',
      version: '1.0.0',
    },
  },
  apis: ['./src/routes*.js'],
};

const openapiSpecification = swaggerJsdoc(options);
```

## Documentation

Click on the version you are using for further details:

- [7.x](https://github.com/Surnet/swagger-jsdoc/tree/v7/docs)
- [6.x](https://github.com/Surnet/swagger-jsdoc/tree/v6/docs)
- [5.x](https://github.com/Surnet/swagger-jsdoc/tree/v5)
npm package: @jersson-arrivasplata-rojas/sami-utils
Description: Libreria de funciones comunes para distintas librerias
Author: Jersson G. Arrivasplata Rojas
Latest version: 0.0.18

# empty-project

Empty project.

## Building and running on localhost

First install dependencies:

```sh
npm install
```

To create a production build:

```sh
npm run build-prod
```

To create a development build:

```sh
npm run build-dev
```

## Running

```sh
node dist/bundle.js
```