You are writing technical documentation for our web application to use as reference. 
You create short concise markdown documents that define how each document in mongodb is structured. 
You define fields, relations and custom indices. 
You use links to other documents like this: [user](user.md), [issue](issue.md), etcetera.

Create the documentation for comment documents.

# Comment Document

The comment document is used to store comments made by users on issues. Each comment is associated with a specific issue and user.

## Fields

- **_id**: ObjectId - The unique identifier for the comment.
- **issueId**: Integer - The id of the issue that the comment is associated with. This is a reference to the [issue](issue.md) document.
- **userId**: ObjectId - The id of the user who made the comment. This is a reference to the [user](user.md) document.
- **text**: String - The text of the comment. This field has a maximum length of 500 characters.
- **timestamp**: Date - The date and time when the comment was posted.

## Relations

- **issue**: Each comment is associated with one issue. The `issueId` field is a reference to the [issue](issue.md) document.
- **user**: Each comment is associated with one user. The `userId` field is a reference to the [user](user.md) document.

## Indices

- **issueId**: An index is created on the `issueId` field to quickly fetch all comments associated with a specific issue.
- **userId**: An index is created on the `userId` field to quickly fetch all comments made by a specific user.

## Example

```json
{
    "_id": ObjectId("60d5ec9af682fbd12a892fe0"),
    "issueId": 1,
    "userId": ObjectId("60d5ec9af682fbd12a892fd7"),
    "text": "This is a comment on the issue.",
    "timestamp": ISODate("2021-06-25T12:00:00Z")
}
```

You are writing technical documentation for our web application to use as reference.
You create short concise markdown documents that define how each document in mongodb is structured. 
You define fields, relations and custom indices.
You use links to other documents like this: [user](user.md), [issue](issue.md), etcetera. 

Create the documentation for issues.

# Issue Document

The issue document is used to store issues reported by users. Each issue is associated with a specific user and can have multiple comments.

## Fields

- **_id**: Integer - The unique identifier for the issue. This field auto increments and is never reused.
- **title**: String - The title of the issue. This field has a maximum length of 100 characters.
- **description**: String - The description of the issue.
- **status**: String - The status of the issue. This field can have one of the following values: 'Open', 'In Progress', 'Closed'.
- **creatorId**: ObjectId - The id of the user who created the issue. This is a reference to the [user](user.md) document.
- **assigneeId**: ObjectId - The id of the user who is assigned to the issue. This is a reference to the [user](user.md) document.

## Relations

- **creator**: Each issue is associated with one user as the creator. The `creatorId` field is a reference to the [user](user.md) document.
- **assignee**: Each issue can be associated with one user as the assignee. The `assigneeId` field is a reference to the [user](user.md) document.
- **comments**: Each issue can have multiple comments. The relation is established via the `issueId` field in the [comment](comment.md) document.

## Indices

- **_id**: An index is created on the `_id` field to quickly fetch issues by their id.
- **creatorId**: An index is created on the `creatorId` field to quickly fetch all issues created by a specific user.
- **assigneeId**: An index is created on the `assigneeId` field to quickly fetch all issues assigned to a specific user.

## Example

```json
{
    "_id": 1,
    "title": "Issue title",
    "description": "This is a description of the issue.",
    "status": "Open",
    "creatorId": ObjectId("60d5ec9af682fbd12a892fd7"),
    "assigneeId": ObjectId("60d5ec9af682fbd12a892fd8")
}
```

You are writing technical documentation for our web application to use as reference.
You create short concise markdown documents that define how each document in mongodb is structured.
You define fields, relations and indices.
You use links to other documents like this: [user](user.md), [issue](issue.md), etcetera.

Create the documentation for determining the next _id for issues.

# Issue ID Generation

The Issue document in the issue management system uses an integer as its unique identifier (`id`), instead of the typical ObjectId used in MongoDB. This `id` is auto-incremented each time a new issue is created. This ensures that each issue has a unique `id` that is never reused.

## Fields

- **id**: Integer - The unique identifier for the issue. This field is auto-incremented each time a new issue is created.

## Auto-Incrementing the Issue ID

To auto-increment the `id` field, we use a separate MongoDB document to keep track of the last used `id`. This document is in a collection called `counters`.

The `counters` collection has a single document for issue `id` generation:

```json
{
    "_id": "issue_id",
    "seq": 0
}
```

The `seq` field stores the last used `id` for issues. When a new issue is created, we increment the `seq` field and use its value for the `id` of the new issue.

Here is a JavaScript function that performs this operation:

```javascript
async function getNextIssueId() {
    const counter = await db.collection('counters').findOneAndUpdate(
        { _id: 'issue_id' },
        { $inc: { seq: 1 } },
        { returnOriginal: false }
    );
    return counter.value.seq;
}
```

This function uses the `findOneAndUpdate` method to atomically increment the `seq` field and return the updated document. The `returnOriginal: false` option ensures that the updated document is returned, not the original one.

## Indices

- **id**: The `id` field should be indexed for faster lookup of issues.

## Relations

- **None**: The `counters` collection does not have any relations with other collections.

## Example

```json
{
    "_id": "issue_id",
    "seq": 123
}
```

This example represents the `counters` document for issue `id` generation. The `seq` field indicates that the `id` of the next issue to be created will be `124`.

Create the openapi document describing comment endpoints on /api/comment that these pages need 
to do queries and updates. Include details like maximum field lengths and query parameters. 
Use the same names for fields as in the mongodb document, including the _id (ObjectId).

Create a list of endpoints on /api/issue that these pages need to do queries and updates. 
Assume that there are already separate endpoints for all other collections.

Here is a list of endpoints that would be needed for the described pages:

1. **GET /api/issue**: Fetches a list of issues. This endpoint should support query parameters for searching and filtering issues. For example, `/api/issue?status=open&assignedTo=johndoe`.

2. **GET /api/issue/{id}**: Fetches the details of a specific issue by its ID.

3. **POST /api/issue**: Creates a new issue. The request body should contain the title and description of the issue.

4. **PUT /api/issue/{id}**: Updates the details of a specific issue. The request body should contain the new status of the issue.

5. **POST /api/issue/{id}/comment**: Adds a new comment to a specific issue. The request body should contain the text of the comment.

6. **GET /api/issue/{id}/comment**: Fetches all comments for a specific issue.

These endpoints should cover all the necessary operations for the described pages. Note that the `{id}` in the URLs should be replaced with the actual ID of the issue.

Create the openapi document describing the GET /api/issue endpoint that this page needs. 
Include a detailed description for each query parameter.

Create the openapi document describing the POST /api/issue endpoint that this page needs. 
Include a detailed description for each query parameter.

# Server

The server for our web application uses NodeJS with Typescript and express to provide a REST API for
the client. The server also connects to a MongoDB database to store and retrieve data using mongoose.
We also use express-validator to validate requests. We use Jest to test our application.
Passport is the library used to authenticate users using a username and password.
Users can also sign up by providing a unique username and password.

Files for the browser are served using express.static. Urls for pages all end with .html 
(example: login.html, sign-up.html).
We use strict Typescript with es6 module syntax, so use export declarations like `export const`
and `export interface`, but do not use `export default`.
Mongoose model files export a model using names like Comment and User along with a Typescript
interface prefixed with an I like IComment and IUser.

Create a sitemap (a description of the folder structure and some main files for our web application) 
to add to the technical documentation. 
Specify locations for routes, mongoose models, jest testcases, demo data and scripts. 
We use src/server.ts as entry point and public/ for static files to serve.

Here's a sitemap for your application:

```
.
├── src
│   ├── server.ts (Entry point for the application)
│   ├── routes (Contains all the route handlers)
│   │   ├── login.ts
│   │   ├── signup.ts
│   │   └── ...
│   ├── models (Contains Mongoose models and corresponding TypeScript interfaces)
│   │   ├── User.ts (Exports IUser and User)
│   │   ├── Comment.ts (Exports IComment and Comment)
│   │   └── ...
│   ├── middleware (Contains middleware functions)
│   │   ├── passport.ts (Passport authentication setup)
│   │   └── ...
│   ├── validators (Contains express-validator validation schemas)
│   │   ├── loginValidator.ts
│   │   ├── signupValidator.ts
│   │   └── ...
│   └── utils (Contains utility functions and scripts)
│       ├── demoData.ts (Script to populate the database with demo data)
│       └── ...
├── public (Contains static files to be served)
│   ├── login.html
│   ├── signup.html
│   └── ...
├── tests (Contains Jest test cases)
│   ├── login.test.ts
│   ├── signup.test.ts
│   └── ...
├── package.json (Lists package dependencies and scripts)
├── tsconfig.json (TypeScript configuration)
└── README.md (Project documentation)
```

This is a general structure and may vary based on your specific application needs. The `...` indicates that there may be other files or directories in that location.

Give me the commands to create the folders mentioned in the sitemap.

Here are the commands you need to initialize your web application:

```bash
# Initialize a new Node.js project
npm init -y

# Install TypeScript
npm install --save-dev typescript

# Initialize a new TypeScript configuration file
npx tsc --init

# Install Express
npm install express

# Install TypeScript types for Node.js and Express
npm install --save-dev @types/node @types/express

# Install other necessary libraries
npm install mongoose express-validator passport
npm install --save-dev @types/mongoose @types/express-validator @types/passport

# Install Jest for testing
npm install --save-dev jest ts-jest @types/jest

# Initialize Jest
npx ts-jest config:init
```

These commands will set up a new Node.js project with TypeScript, Express, Mongoose, express-validator, Passport, and Jest. The `--save-dev` flag is used to save packages for development purposes (like TypeScript and Jest), while the other packages are saved as regular dependencies.

write a concise .gitignore file for this application

Create the content of src/server.ts with the specified authentication, middlewares, 
static file serving and a placeholder where to add routes later.

Tell me how to start the server. The server should auto reload changes.

To start the server with auto-reloading on changes, you can use a tool like `nodemon` which will watch your files and restart the server whenever a file changes.

First, you need to install `nodemon` as a development dependency. You can do this by running the following command in your terminal:

```bash
npm install --save-dev nodemon
```

Then, you need to add a start script to your `package.json` file that uses `nodemon` to run your server file. Assuming your server file is `src/server.ts`, you can add the following script:

```json
"scripts": {
  "start": "nodemon --watch 'src/**/*.ts' --exec 'ts-node' src/server.ts"
}
```

This script tells `nodemon` to watch all `.ts` files in the `src` directory and its subdirectories, and to use `ts-node` to execute your `src/server.ts` file whenever a file changes.

Finally, you can start your server with the following command:

```bash
npm start
```

This will start your server and it will automatically restart whenever you make changes to any `.ts` file in the `src` directory or its subdirectories.

Implement the mongoose schema and interface for comment. Include indices.

Give me the complete files with the implementation of this endpoint 
and the code to add to server.ts to register it.

To implement the endpoint for creating and fetching comments, you would need to create a new file in the `routes` directory. Let's call it `comment.ts`. 

Here's the code for `comment.ts`:

```typescript
import express from 'express';
import { body, validationResult } from 'express-validator';
import { Comment, IComment } from '../models/Comment';

const router = express.Router();

// Validation middleware for creating a new comment
const commentValidator = [
  body('issueId').isInt(),
  body('userId').isMongoId(),
  body('text').isLength({ max: 500 }),
];

router.post('/api/comment', commentValidator, async (req, res) => {
  const errors = validationResult(req);
  if (!errors.isEmpty()) {
    return res.status(400).json({ errors: errors.array() });
  }

  const { issueId, userId, text } = req.body;
  const comment: IComment = new Comment({ issueId, userId, text });

  await comment.save();

  res.status(201).json(comment);
});

router.get('/api/comment', async (req, res) => {
  const { issueId } = req.query;

  if (!issueId) {
    return res.status(400).json({ error: 'issueId query parameter is required' });
  }

  const comments = await Comment.find({ issueId });

  res.json(comments);
});

export default router;
```

Then, you would need to import this router in your `server.ts` file and use it:

```typescript
import express from 'express';
import commentRouter from './routes/comment';

const app = express();

app.use(express.json());
app.use(commentRouter);

// other middleware and routes...

app.listen(3000, () => {
  console.log('Server is running on port 3000');
});
```

This code creates two endpoints: `POST /api/comment` for creating a new comment and `GET /api/comment` for fetching comments for a specific issue. The `POST /api/comment` endpoint uses express-validator to validate the request body.

Implement the mongoose schema and interface for issue. Include indices. 
End every line of code with //NEWLINE

Here is the TypeScript code to implement the Mongoose schema and interface for the Issue document. This code includes custom indices for the `_id`, `creatorId`, and `assigneeId` fields.

```typescript
import mongoose, { Document, Schema } from 'mongoose';

// Define the Issue interface
export interface IIssue extends Document {
  _id: number;
  title: string;
  description: string;
  status: string;
  creatorId: mongoose.Types.ObjectId;
  assigneeId: mongoose.Types.ObjectId;
}

// Define the Issue schema
const IssueSchema = new Schema<IIssue>({
  _id: { type: Number, required: true },  //NEWLINE
  title: { type: String, required: true, maxlength: 100 },  //NEWLINE
  description: { type: String, required: true },  //NEWLINE
  status: { type: String, required: true, enum: ['Open', 'In Progress', 'Closed'] },  //NEWLINE
  creatorId: { type: mongoose.Types.ObjectId, required: true, ref: 'User' },  //NEWLINE
  assigneeId: { type: mongoose.Types.ObjectId, ref: 'User' }  //NEWLINE
});

// Define the custom indices
IssueSchema.index({ _id: 1 });  //NEWLINE
IssueSchema.index({ creatorId: 1 });  //NEWLINE
IssueSchema.index({ assigneeId: 1 });  //NEWLINE

// Export the Issue model
export const Issue = mongoose.model<IIssue>('Issue', IssueSchema);  //NEWLINE
```

Give me the complete files with the implementation of this endpoint 
and the code to add to server.ts to register it.

Add request validation

Give me the complete files with the implementation of this endpoint including request validation 
and the code to add to server.ts to register it.

give me the implementation of `issueIdGenerator`

Create a Typescript script that adds 2 issues containing 2 comments each to the database 
using the mongoose schemas above. Hardcode all user ids with the same value for now. 
Make realistic issues about a fictional government tax application web application.

# Client

We use static html files to create the frontend, 
styled using Bulma css and use vanilla javascript to load json data from the apis.
All page urls end with .html
We also use htmx to split up the html into smaller components. 
This is done using the `hx-get` and `hx-trigger="load"` attribute.
Common elements like the user-menu can be found in the public/partials/ folder.
All pages include a consistent navbar.

You are writing technical documentation for our web application to use as reference. 
You create short concise markdown documents. 
Create a short "Sitemap" document that contains a list of the html files that we need
to fulfill these usecases and specify query-string parameters if applicable. 
We need it to create the navigation between pages.

# Sitemap

Here is a list of the HTML files that we need to fulfill the use cases. Each file corresponds to a specific page in the web application.

1. **index.html**: The home page of the application. No query-string parameters.

2. **issue-list.html**: The page that displays a list of all issues. Query-string parameters:
    - `search`: The search query to filter issues by title or description.
    - `status`: The status to filter issues by (Open, In Progress, Closed).
    - `assignedTo`: The user to filter issues by who they are assigned to.

3. **issue-details.html**: The page that displays the details of a specific issue. Query-string parameters:
    - `id`: The ID of the issue to display.

4. **create-issue.html**: The page that allows users to create a new issue. No query-string parameters.

5. **edit-issue.html**: The page that allows users to edit an existing issue. Query-string parameters:
    - `id`: The ID of the issue to edit.

6. **user-profile.html**: The page that displays the profile of a specific user. Query-string parameters:
    - `username`: The username of the user to display.

7. **login.html**: The page that allows users to log in. No query-string parameters.

8. **register.html**: The page that allows users to register a new account. No query-string parameters.

Please note that the `id` and `username` parameters should be properly URL-encoded to ensure that they can be correctly interpreted by the server.

Create a blank plain template.html page that can be used as a starting point for pages like
create-issue.html. It includes a navbar with a home link and a lazy loaded user menu. 
There is one placeholder where the main page content can be placed. please make the navbar stand out.

create the new-issue.html page. 
it contains inline javascript for the client side logic and interacts with the server using /api.

Before creating the issue-list.html, decide on a concise list of selectors the javascript needs to make the page interactive.

Create the complete issue-list.html page using these selectors. Style the elements using Bulma css.

Create the needed javascript es6 module for this page.

give me the implementation of api.js. Return an empty array for `getUsers` for now.