@nishanprime/sku-generator

# SKU Generator (TypeORM + PostgreSQL)

A lightweight utility for generating and retrieving SKUs (Stock Keeping Units) stored in a PostgreSQL database using TypeORM. This library:

- Connects to PostgreSQL once and reuses the same connection until explicitly closed.  
- Checks if a SKU already exists for a given manufacturer and part number.  
- Creates a new SKU if none exists.  
- Stores and retrieves SKUs in a database table (named `skus` by default if using `@Entity('skus')`).

## Table of Contents

- [Installation](#installation)
- [Usage](#usage)
  - [Constructor Parameters](#constructor-parameters)
  - [Basic Example](#basic-example)
  - [Multiple Calls Example](#multiple-calls-example)
- [Methods](#methods)
  - [`init()`](#init)
  - [`getOrCreateSKU(params)`](#getorcreateskuparams)
  - [`close()`](#close)
- [Environment Variables](#environment-variables)
- [License](#license)

---

## Installation

```bash
npm install @nishanprime/sku-generator

---

Usage

Constructor Parameters

/**
 * The options you can pass to the constructor:
 * {
 *   url: string;          // PostgreSQL connection string
 *   synchronize: boolean; // Whether to auto-sync the database schema
 *   logging: boolean;     // Enable TypeORM query logging
 *   extra: {
 *     max: number;                  // Max DB connections in the pool
 *     idleTimeoutMillis: number;    // Idle timeout in ms
 *     connectionTimeoutMillis: number; // Connection timeout in ms
 *   };
 * }
 */

• url: The connection string for your Postgres DB. E.g. "postgres://user:pass@localhost:5432/dbname".
• synchronize: In development, true can auto-create or update tables. In production, you typically use migrations and set this to false.
• logging: Prints SQL queries to the console if true.
• extra: Pool settings (default values shown in the code).

If you omit these options, it will look for a POSTGRES_CONNECTION_STRING in your environment variables.

Basic Example

import { SKUGenerator } from "@nishanprime/sku-generator";

(async () => {
  // Create a new SKUGenerator instance with optional connection settings
  const skuGen = new SKUGenerator({
    url: "postgres://user:password@localhost:5432/mydb",
    synchronize: true,  // For dev only
    logging: false,      
    extra: {
      max: 10,
      idleTimeoutMillis: 30000,
      connectionTimeoutMillis: 5000,
    },
  });

  // Make sure the data source is initialized
  await skuGen.init();

  // Generate or get an existing SKU
  const sku = await skuGen.getOrCreateSKU({
    manufacturerName: "Apple",
    manufacturerPartNumber: "M1Chip",
    category: "Laptop",
    subcategory: "MacBook",
  });

  console.log("Generated or retrieved SKU:", sku);

  // Close the connection when done
  await skuGen.close();
})();

Multiple Calls Example

If you have to process many items, you can do something like:

import { SKUGenerator } from "@nishanprime/sku-generator";

(async () => {
  const skuGen = new SKUGenerator({
    url: "postgres://user:password@localhost:5432/mydb",
    synchronize: false,
    logging: false,
  });

  await skuGen.init(); // connect once

  const products = [
    { manufacturerName: "Apple", manufacturerPartNumber: "M1Chip", category: "Laptop", subcategory: "MacBook" },
    { manufacturerName: "Intel", manufacturerPartNumber: "i7-12700", category: "CPU" },
    // ... potentially thousands more
  ];

  for (const product of products) {
    const sku = await skuGen.getOrCreateSKU(product);
    console.log("SKU for", product.manufacturerPartNumber, ":", sku);
  }

  await skuGen.close(); // close after all operations
})();

In this example, the connection is opened once (init()) and stays open until you explicitly close() it, which is important for performance when dealing with bulk operations.

---

Methods

init()

public async init(): Promise<void>;

Ensures the data source is initialized exactly once.

• If the data source is already initialized, this does nothing.
• Otherwise, it connects to PostgreSQL using the provided URL or the POSTGRES_CONNECTION_STRING environment variable.

getOrCreateSKU(params)

public async getOrCreateSKU(params: SKUParams): Promise<string>;

• Params:

  interface SKUParams {
    manufacturerName: string;
    manufacturerPartNumber: string;
    category: string;
    subcategory?: string;
  }

• Behavior:
  1. Checks if a row with the same manufacturerName and manufacturerPartNumber already exists.
  2. If it does, returns the existing sku.
  3. If not, generates a new SKU (e.g., A5<6-digit-random><first-letter-of-category><first-letter-of-subcategory-or-second-letter-of-category>) and inserts a new row into the DB.
  4. Returns the newly created SKU string.

close()

public async close(): Promise<void>;

• Closes the database connection (destroying the TypeORM data source).
• Once closed, you can re-init if needed, but typically you close just before your application ends or if you no longer need SKU operations.

---

Environment Variables

• POSTGRES_CONNECTION_STRING: If you do not pass a url in the constructor, this library will attempt to use process.env.POSTGRES_CONNECTION_STRING.
  • For example:

    export POSTGRES_CONNECTION_STRING="postgres://user:pass@localhost:5432/dbname"

• You can also configure the pool and logging behavior via constructor options or by editing your environment variables. However, the library as shown expects direct constructor options for advanced settings.

---

License

MIT
Feel free to modify, distribute, and use this library in your own projects under the terms of the MIT license.