open-index/open-npm huggingface dataset:
npm package: @piayo/web-components-full-year
Description: A Web Component that shows the current year
Author: piayo
Latest version: 1.0.0

# web-components-full-year

A Web Component that shows the current year, using data from GetFullYear.com.

Usage

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <script type="module" src="./wc.full-year.min.js"></script>
</head>
<body>
    © <full-year></full-year> MySiteName
</body>
</html>
```
npm package: @pib-statuslamp/sparkfun-canbusshield_node-red
Description: Node-RED support for Sparkfun CAN bus shield. can send and recieve canbus data via the sparkfun canbusshield.
Latest version: 0.4.5

# SparkfunCanbusshield-NodeRED
Node-RED support for Sparkfun CAN bus shield. can send and recieve canbus data and control leds.

This is a work in progress.
npm package: @piber/hello-world
Description: First hello world to the world
Author: Maurício Piber Fão
Latest version: 1.4.1

# Hello World

I just came to say hello.

I encourage everyone to break the cavern layers of their minds and be part of the universe.

## Links

[GitHub](https://github.com/mauriciopiber)

[Instagram](https://www.instagram.com/m.piber)

[Facebook](https://www.facebook.com/mauricio.piber)

[Website](www.mauriciopiber.com)

[Twitter](https://x.com/mauricio_piber)

## License

[MIT](https://choosealicense.com/licenses/mit/)
npm package: @piber/rollup-react
Description: Starter template for building JS libraries using Rollup
Author: Maurício Piber Fão
Latest version: 0.1.1

# Rollup React

This is a simple example of React component library build using Rollup

## Kudos

Kudos to [Mykhaylo Ryechkin](https://github.com/mryechkin) by solving the enigma of 'use client' with Rollup.

This repository is a clone from [this](https://github.com/mryechkin/rollup-library-starter) with a few additions.
npm package: @pic-nivo/pie
Description: [![version](https://img.shields.io/npm/v/@nivo/pie.svg?style=flat-square)](https://www.npmjs.com/package/@nivo/pie)
Author: Raphaël Benitte
Latest version: 0.59.5

# `@nivo/pie`

[![version](https://img.shields.io/npm/v/@nivo/pie.svg?style=flat-square)](https://www.npmjs.com/package/@nivo/pie)

## Pie

[documentation](http://nivo.rocks/pie)

![Pie](./doc/pie.png)
npm package: @picadeck/core
Description: Core schema visualizer - Express middleware, HTML renderer, types, and layout
Author: Picadeck
Latest version: 1.0.0

# @picadeck/core

Core package for Picadeck Schema Visualizer. Provides Express middleware, HTML renderer, types, and auto-layout for interactive database schema visualization.

## Installation

```bash
npm install @picadeck/core
```

## Usage with Express

```typescript
import express from "express";
import { schemaVisualizer } from "@picadeck/core";
import { parseMongooseModels } from "@picadeck/mongoose-parser";
import { User, Post } from "./models";

const app = express();

app.use(
  "/schema",
  schemaVisualizer({
    parser: parseMongooseModels,
    models: [User, Post],
    theme: "dark",
    title: "My App Schema",
  })
);

app.listen(3000, () => {
  console.log("Visit http://localhost:3000/schema");
});
```

## API

### `schemaVisualizer(options)`

Creates Express middleware that serves an interactive schema visualizer.

**Options:**

| Option   | Type                        | Required | Description                          |
| -------- | --------------------------- | -------- | ------------------------------------ |
| `parser` | `ParserFunction`            | Yes      | Parser function from any `@picadeck` parser package |
| `models` | `any[]`                     | Yes      | Array of models/schemas to visualize |
| `theme`  | `'light' \| 'dark'`        | No       | UI theme (default: `'light'`)        |
| `title`  | `string`                    | No       | Page title                           |

### `generateHTML(schema, theme?)`

Generates a self-contained HTML string with the embedded visualizer.

- `schema` — `UniversalSchema` object
- `theme` — `'light' | 'dark'` (default: `'light'`)

### `calculateLayout(schema)` / `applyLayout(schema)`

Utility functions for computing and applying automatic node positions.

## Types

All parsers produce `UniversalSchema`, which contains:

- `Entity` — a table or collection with `Field[]`, `Index[]`, and `Constraint[]`
- `Field` — column definition with `normalizedType`, nullability, keys, defaults
- `Relationship` — one-to-one, one-to-many, or many-to-many link between entities
- `NormalizedType` — cross-framework type enum (`STRING`, `INTEGER`, `BOOLEAN`, `JSON`, `UUID`, etc.)

## Features

- Light and dark theme support with CSS variables
- Interactive ReactFlow-based visualization (pan, zoom, drag)
- Automatic hierarchical layout algorithm
- Relationship mapping with cardinality indicators
- Single self-contained HTML response (no external requests)
- Schema injected via `window.__PICADECK_SCHEMA__`

## License

MIT
npm package: @picadeck/drizzle-parser
Description: Drizzle ORM schema parser for Picadeck schema visualizer
Author: Picadeck
Latest version: 1.0.0

# @picadeck/drizzle-parser

Drizzle ORM parser for Picadeck Schema Visualizer. Converts Drizzle schema objects into `UniversalSchema` for interactive visualization.

## Installation

```bash
npm install @picadeck/drizzle-parser @picadeck/core
```

**Peer dependency:** `drizzle-orm` 0.30.x -- 0.38.x

## Usage

```typescript
import express from "express";
import { schemaVisualizer } from "@picadeck/core";
import { parseDrizzleSchema } from "@picadeck/drizzle-parser";
import * as schema from "./db/schema";

const app = express();

app.use(
  "/schema",
  schemaVisualizer({
    parser: () => parseDrizzleSchema(schema),
    models: [],
    theme: "dark",
  })
);

app.listen(3000);
```

## API

### `parseDrizzleSchema(schema, database?)`

Parses Drizzle table definitions into a `UniversalSchema`.

```typescript
import { parseDrizzleSchema } from "@picadeck/drizzle-parser";
import * as schema from "./db/schema";

const result = parseDrizzleSchema(schema, "postgresql");
```

The `schema` parameter is the module object containing your Drizzle table definitions (e.g., `pgTable`, `mysqlTable`, `sqliteTable`).

The optional `database` parameter (`'postgresql' | 'mysql' | 'sqlite'`) improves type normalization. If omitted, it is inferred from the table builder functions.

## Supported Databases

- PostgreSQL (`pgTable`, `pgEnum`)
- MySQL (`mysqlTable`, `mysqlEnum`)
- SQLite (`sqliteTable`)

## License

MIT
npm package: @picadeck/mongoose-parser
Description: Mongoose schema parser for Picadeck schema visualizer
Author: Picadeck
Latest version: 1.0.0

# @picadeck/mongoose-parser

Mongoose schema parser for Picadeck Schema Visualizer. Converts Mongoose models into `UniversalSchema` for interactive visualization.

## Installation

```bash
npm install @picadeck/mongoose-parser @picadeck/core
```

**Peer dependency:** `mongoose` 7.x or 8.x

## Usage

```typescript
import express from "express";
import { schemaVisualizer } from "@picadeck/core";
import { parseMongooseModels } from "@picadeck/mongoose-parser";
import { User, Post, Comment } from "./models";

const app = express();

app.use(
  "/schema",
  schemaVisualizer({
    parser: parseMongooseModels,
    models: [User, Post, Comment],
    theme: "dark",
  })
);
```

## API

### `parseMongooseModels(models)`

Parses an array of Mongoose model classes into a `UniversalSchema`.

```typescript
import { parseMongooseModels } from "@picadeck/mongoose-parser";

const schema = parseMongooseModels([User, Post]);
```

### `parseMongooseConnection(connection)`

Parses all registered models from a Mongoose connection instance. Useful with NestJS dependency injection.

```typescript
import { parseMongooseConnection } from "@picadeck/mongoose-parser";
import mongoose from "mongoose";

const schema = parseMongooseConnection(mongoose.connection);
```

## NestJS Compatibility

`@nestjs/mongoose` decorators (`@Schema()`, `@Prop()`) compile to standard `mongoose.Schema` at runtime. This parser works as-is with NestJS -- no additional adapter needed. Use `parseMongooseConnection(connection)` with the injected Mongoose connection.

## License

MIT
npm package: @picadeck/nextjs
Description: Next.js integration for Picadeck schema visualizer
Author: Picadeck
Latest version: 1.0.0

# @picadeck/nextjs

Next.js App Router handler for Picadeck Schema Visualizer. Serves an interactive schema visualization page from a Next.js API route.

## Installation

```bash
npm install @picadeck/nextjs @picadeck/core
```

Plus the parser package for your ORM:

```bash
npm install @picadeck/mongoose-parser   # for Mongoose
npm install @picadeck/prisma-parser      # for Prisma
npm install @picadeck/drizzle-parser     # for Drizzle
# ... or any other @picadeck parser
```

## Usage

Create a route handler in your Next.js App Router:

```typescript
// app/api/schema/route.ts
import { createSchemaHandler } from "@picadeck/nextjs";
import { parsePrismaFile } from "@picadeck/prisma-parser";

export const GET = createSchemaHandler({
  parser: () => parsePrismaFile("./prisma/schema.prisma"),
  theme: "dark",
  title: "My App Schema",
});
```

Then visit `http://localhost:3000/api/schema` to see the visualization.

## API

### `createSchemaHandler(options)`

Returns a Next.js App Router `GET` handler that serves the schema visualizer as a self-contained HTML page.

| Option   | Type                                  | Required | Description                     |
| -------- | ------------------------------------- | -------- | ------------------------------- |
| `parser` | `() => UniversalSchema \| Promise<UniversalSchema>` | Yes | Function that returns a schema |
| `theme`  | `'light' \| 'dark'`                  | No       | UI theme (default: `'light'`)   |
| `title`  | `string`                              | No       | Page title                      |

### `SchemaHandlerOptions`

TypeScript interface for the options object, exported for type safety.

## Example with Drizzle

```typescript
// app/api/schema/route.ts
import { createSchemaHandler } from "@picadeck/nextjs";
import { parseDrizzleSchema } from "@picadeck/drizzle-parser";
import * as schema from "@/db/schema";

export const GET = createSchemaHandler({
  parser: () => parseDrizzleSchema(schema, "postgresql"),
  theme: "light",
});
```

## License

MIT
npm package: @picadeck/prisma-parser
Description: Prisma schema file parser for Picadeck schema visualizer
Author: Picadeck
Latest version: 1.0.0

# @picadeck/prisma-parser

Prisma schema parser for Picadeck Schema Visualizer. Reads `.prisma` schema files and converts them into `UniversalSchema` for interactive visualization.

## Installation

```bash
npm install @picadeck/prisma-parser @picadeck/core
```

No peer dependency on Prisma is required -- this package reads `.prisma` files directly using `@mrleebo/prisma-ast`.

## Usage

```typescript
import express from "express";
import { schemaVisualizer } from "@picadeck/core";
import { parsePrismaFile } from "@picadeck/prisma-parser";

const app = express();

app.use(
  "/schema",
  schemaVisualizer({
    parser: () => parsePrismaFile("./prisma/schema.prisma"),
    models: [],
    theme: "dark",
  })
);

app.listen(3000);
```

## API

### `parsePrismaFile(filePath)`

Reads a `.prisma` file from disk and parses it into a `UniversalSchema`.

```typescript
import { parsePrismaFile } from "@picadeck/prisma-parser";

const schema = await parsePrismaFile("./prisma/schema.prisma");
```

### `parsePrismaSchema(schemaContent)`

Parses a Prisma schema string directly (useful when the content is already in memory).

```typescript
import { parsePrismaSchema } from "@picadeck/prisma-parser";

const content = fs.readFileSync("./prisma/schema.prisma", "utf-8");
const schema = parsePrismaSchema(content);
```

## Framework Agnostic

Prisma uses a `.prisma` DSL file regardless of your backend framework. This parser works the same whether you use Express, NestJS, Fastify, or any other Node.js framework.

## License

MIT
npm package: @picadeck/sequelize-parser
Description: Sequelize schema parser for Picadeck schema visualizer
Author: Picadeck
Latest version: 1.0.0

# @picadeck/sequelize-parser

Sequelize parser for Picadeck Schema Visualizer. Converts Sequelize models into `UniversalSchema` for interactive visualization.

## Installation

```bash
npm install @picadeck/sequelize-parser @picadeck/core
```

**Peer dependency:** `sequelize` 6.x or 7.x

## Usage

```typescript
import express from "express";
import { schemaVisualizer } from "@picadeck/core";
import { parseSequelizeInstance } from "@picadeck/sequelize-parser";
import { sequelize } from "./database";

const app = express();

app.use(
  "/schema",
  schemaVisualizer({
    parser: () => parseSequelizeInstance(sequelize),
    models: [],
    theme: "light",
  })
);

app.listen(3000);
```

## API

### `parseSequelizeInstance(sequelize)`

Parses all models registered on a Sequelize instance.

```typescript
import { parseSequelizeInstance } from "@picadeck/sequelize-parser";

const schema = parseSequelizeInstance(sequelize);
```

### `parseSequelizeModels(models, database?)`

Parses an array of Sequelize model classes directly.

```typescript
import { parseSequelizeModels } from "@picadeck/sequelize-parser";
import { User, Post } from "./models";

const schema = parseSequelizeModels([User, Post], "mysql");
```

The optional `database` parameter (`'postgresql' | 'mysql' | 'sqlite' | 'mssql'`) improves type normalization accuracy. If omitted, it is inferred from the model's Sequelize instance when possible.

## NestJS Compatibility

`@nestjs/sequelize` registers a Sequelize instance in the NestJS DI container. Inject it and pass it to `parseSequelizeInstance()` directly.

## License

MIT
npm package: @picadeck/sql-parser
Description: SQL DDL parser for Picadeck schema visualizer
Author: Picadeck
Latest version: 1.0.0

# @picadeck/sql-parser

SQL DDL parser for Picadeck Schema Visualizer. Parses raw SQL `CREATE TABLE` statements into `UniversalSchema` for interactive visualization.

## Installation

```bash
npm install @picadeck/sql-parser @picadeck/core
```

No peer dependencies -- uses `node-sql-parser` internally.

## Usage

```typescript
import express from "express";
import { schemaVisualizer } from "@picadeck/core";
import { parseSQLFile } from "@picadeck/sql-parser";

const app = express();

app.use(
  "/schema",
  schemaVisualizer({
    parser: () => parseSQLFile("./schema.sql", "postgresql"),
    models: [],
    theme: "light",
  })
);

app.listen(3000);
```

## API

### `parseSQLToSchema(sql, dialect)`

Parses a SQL DDL string into a `UniversalSchema`.

```typescript
import { parseSQLToSchema } from "@picadeck/sql-parser";

const result = parseSQLToSchema(
  `CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    name VARCHAR(255) NOT NULL
  );`,
  "postgresql"
);

if (result.success) {
  console.log(result.schema);
} else {
  console.error(result.error);
}
```

### `parseSQLFile(filePath, dialect)`

Reads a `.sql` file from disk and parses it.

```typescript
import { parseSQLFile } from "@picadeck/sql-parser";

const result = await parseSQLFile("./migrations/schema.sql", "mysql");
```

### Return Format

Both functions return `{ success: true, schema: UniversalSchema }` on success or `{ success: false, error: string }` on failure.

### `SQLDialect`

Supported dialects: `'postgresql'` | `'mysql'`

## License

MIT
npm package: @picadeck/typeorm-parser
Description: TypeORM DataSource parser for Picadeck schema visualizer
Author: Picadeck
Latest version: 1.0.0

# @picadeck/typeorm-parser

TypeORM parser for Picadeck Schema Visualizer. Converts a TypeORM `DataSource` into `UniversalSchema` for interactive visualization.

## Installation

```bash
npm install @picadeck/typeorm-parser @picadeck/core
```

**Peer dependency:** `typeorm` 0.3.x

## Usage

```typescript
import express from "express";
import { schemaVisualizer } from "@picadeck/core";
import { parseTypeormDataSource } from "@picadeck/typeorm-parser";
import { AppDataSource } from "./data-source";

const app = express();

AppDataSource.initialize().then(() => {
  app.use(
    "/schema",
    schemaVisualizer({
      parser: () => parseTypeormDataSource(AppDataSource),
      models: [],
      theme: "light",
    })
  );

  app.listen(3000);
});
```

## API

### `parseTypeormDataSource(dataSource)`

Parses all entity metadata from an initialized TypeORM `DataSource`.

```typescript
import { parseTypeormDataSource } from "@picadeck/typeorm-parser";

const schema = parseTypeormDataSource(dataSource);
```

### `parseTypeormEntities(entities)`

Parses an array of TypeORM entity classes directly.

```typescript
import { parseTypeormEntities } from "@picadeck/typeorm-parser";
import { User, Post } from "./entities";

const schema = parseTypeormEntities([User, Post]);
```

## NestJS Compatibility

`@nestjs/typeorm` is a thin DI wrapper around TypeORM. Entities use the same `typeorm` decorators, so this parser works as-is. Inject the `DataSource` using `@InjectDataSource()` and pass it to `parseTypeormDataSource()`.

## License

MIT
npm package: @picahq/authkit-node
Description: Secure token generation for Pica AuthKit
Author: @picahq
Latest version: 2.0.1

# authkit-node

Secure token generation for [Pica AuthKit](https://docs.picaos.com/docs/authkit) using [Node.js](https://nodejs.org/en) .

## Install

With npm:

```jsx
npm i @picahq/authkit-node
```

With yarn:

```jsx
yarn add @picahq/authkit-node
```

## Creating a token endpoint

You'll want to create an internal endpoint that's used to generate secure tokens for your frontend. You can do so by adding code that looks like the below snippet.

```jsx
import { AuthKitToken } from "@picahq/authkit-node";

app.post("/authkit-token", async (request, response) => {
  const authKitToken = new AuthKitToken("sk_live_1234");
  const token = await authKitToken.create();

  response.send(token);
});
```

You'll want to switch out the API Key for your own, which will later tell your frontend which integrations you'd like to make available to your users.

If you pass an `identity` or `identityType` (`user`, `team`, `organization`, or `project`), you'll be able to query for all connections scoped to that identity. The identity is used to generate the unique [Connection Key](https://docs.picaos.com/docs/setup) for the user once they successfully connect an account.

## Full Documentation

Please refer to the official [Pica AuthKit](https://docs.picaos.com/docs/authkit) docs for a more holistic understanding of Pica AuthKit.