startx 0.1.5 → 0.2.0

package/configs/eslint-config/src/rules/no-type-unsafe-event-emitter.ts

@@ -1,33 +1,33 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-
-export const NoTypeUnsafeEventEmitterRule = ESLintUtils.RuleCreator.withoutDocs({
-	name: 'no-type-unsafe-event-emitter',
-	meta: {
-		type: 'problem',
-		docs: {
-			description: 'Disallow extending from `EventEmitter`, which is not type-safe.',
-		},
-		messages: {
-			noExtendsEventEmitter: 'Extend from the type-safe `TypedEmitter` class instead.',
-		},
-		schema: [],
-	},
-	defaultOptions: [],
-	create(context) {
-		return {
-			ClassDeclaration(node) {
-				if (
-					node.superClass &&
-					node.superClass.type === 'Identifier' &&
-					node.superClass.name === 'EventEmitter' &&
-					node.id?.name !== 'TypedEmitter'
-				) {
-					context.report({
-						node: node.superClass,
-						messageId: 'noExtendsEventEmitter',
-					});
-				}
-			},
-		};
-	},
-});
+import { ESLintUtils } from '@typescript-eslint/utils';
+
+export const NoTypeUnsafeEventEmitterRule = ESLintUtils.RuleCreator.withoutDocs({
+	name: 'no-type-unsafe-event-emitter',
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow extending from `EventEmitter`, which is not type-safe.',
+		},
+		messages: {
+			noExtendsEventEmitter: 'Extend from the type-safe `TypedEmitter` class instead.',
+		},
+		schema: [],
+	},
+	defaultOptions: [],
+	create(context) {
+		return {
+			ClassDeclaration(node) {
+				if (
+					node.superClass &&
+					node.superClass.type === 'Identifier' &&
+					node.superClass.name === 'EventEmitter' &&
+					node.id?.name !== 'TypedEmitter'
+				) {
+					context.report({
+						node: node.superClass,
+						messageId: 'noExtendsEventEmitter',
+					});
+				}
+			},
+		};
+	},
+});

package/configs/eslint-config/src/rules/no-uncaught-json-parse.test.ts

@@ -1,21 +1,21 @@
-import { RuleTester } from "@typescript-eslint/rule-tester";
-import { NoUncaughtJsonParseRule } from "./no-uncaught-json-parse.js";
-
-const ruleTester = new RuleTester();
-
-ruleTester.run("no-uncaught-json-parse", NoUncaughtJsonParseRule, {
-  valid: [
-    {
-      code: "try { JSON.parse(foo) } catch (e) {}",
-    },
-    {
-      code: "JSON.parse(JSON.stringify(foo))",
-    },
-  ],
-  invalid: [
-    {
-      code: "JSON.parse(foo)",
-      errors: [{ messageId: "noUncaughtJsonParse" }],
-    },
-  ],
-});
+import { RuleTester } from "@typescript-eslint/rule-tester";
+import { NoUncaughtJsonParseRule } from "./no-uncaught-json-parse.js";
+
+const ruleTester = new RuleTester();
+
+ruleTester.run("no-uncaught-json-parse", NoUncaughtJsonParseRule, {
+  valid: [
+    {
+      code: "try { JSON.parse(foo) } catch (e) {}",
+    },
+    {
+      code: "JSON.parse(JSON.stringify(foo))",
+    },
+  ],
+  invalid: [
+    {
+      code: "JSON.parse(foo)",
+      errors: [{ messageId: "noUncaughtJsonParse" }],
+    },
+  ],
+});

package/configs/eslint-config/src/rules/no-untyped-config-class-field.ts

@@ -1,26 +1,26 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-
-export const NoUntypedConfigClassFieldRule = ESLintUtils.RuleCreator.withoutDocs({
-	name: "no-untyped-config-class-field",
-	meta: {
-		type: 'problem',
-		docs: {
-			description: 'Enforce explicit typing of config class fields',
-		},
-		messages: {
-			noUntypedConfigClassField:
-				'Class field must have an explicit type annotation, e.g. `field: type = value`.',
-		},
-		schema: [],
-	},
-	defaultOptions: [],
-	create(context) {
-		return {
-			PropertyDefinition(node) {
-				if (!node.typeAnnotation) {
-					context.report({ node: node.key, messageId: 'noUntypedConfigClassField' });
-				}
-			},
-		};
-	},
-});
+import { ESLintUtils } from '@typescript-eslint/utils';
+
+export const NoUntypedConfigClassFieldRule = ESLintUtils.RuleCreator.withoutDocs({
+	name: "no-untyped-config-class-field",
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Enforce explicit typing of config class fields',
+		},
+		messages: {
+			noUntypedConfigClassField:
+				'Class field must have an explicit type annotation, e.g. `field: type = value`.',
+		},
+		schema: [],
+	},
+	defaultOptions: [],
+	create(context) {
+		return {
+			PropertyDefinition(node) {
+				if (!node.typeAnnotation) {
+					context.report({ node: node.key, messageId: 'noUntypedConfigClassField' });
+				}
+			},
+		};
+	},
+});

package/configs/eslint-config/src/rules/no-unused-param-catch-clause.ts

@@ -1,33 +1,33 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-
-export const NoUnusedParamInCatchClauseRule = ESLintUtils.RuleCreator.withoutDocs({
-	name: "no-unused-param-catch-clause",
-	meta: {
-		type: 'problem',
-		docs: {
-			description: 'Unused param in catch clause must be omitted.',
-		},
-		messages: {
-			removeUnusedParam: 'Remove unused param in catch clause',
-		},
-		fixable: 'code',
-		schema: [],
-	},
-	defaultOptions: [],
-	create(context) {
-		return {
-			CatchClause(node) {
-				if (node.param?.type === 'Identifier' && node.param.name.startsWith('_')) {
-					const start = node.range[0] + 'catch '.length;
-					const end = node.param.range[1] + '()'.length;
-
-					context.report({
-						messageId: 'removeUnusedParam',
-						node,
-						fix: (fixer) => fixer.removeRange([start, end]),
-					});
-				}
-			},
-		};
-	},
-});
+import { ESLintUtils } from '@typescript-eslint/utils';
+
+export const NoUnusedParamInCatchClauseRule = ESLintUtils.RuleCreator.withoutDocs({
+	name: "no-unused-param-catch-clause",
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Unused param in catch clause must be omitted.',
+		},
+		messages: {
+			removeUnusedParam: 'Remove unused param in catch clause',
+		},
+		fixable: 'code',
+		schema: [],
+	},
+	defaultOptions: [],
+	create(context) {
+		return {
+			CatchClause(node) {
+				if (node.param?.type === 'Identifier' && node.param.name.startsWith('_')) {
+					const start = node.range[0] + 'catch '.length;
+					const end = node.param.range[1] + '()'.length;
+
+					context.report({
+						messageId: 'removeUnusedParam',
+						node,
+						fix: (fixer) => fixer.removeRange([start, end]),
+					});
+				}
+			},
+		};
+	},
+});

package/configs/eslint-config/src/rules/no-useless-catch-throw.test.ts

@@ -1,34 +1,34 @@
-import { RuleTester } from "@typescript-eslint/rule-tester";
-import { NoUselessCatchThrowRule } from "./no-useless-catch-throw.js";
-
-const ruleTester = new RuleTester();
-
-ruleTester.run("no-useless-catch-throw", NoUselessCatchThrowRule, {
-  valid: [
-    {
-      code: "try { foo(); } catch (e) { console.error(e); }",
-    },
-    {
-      code: 'try { foo(); } catch (e) { throw new Error("Custom error"); }',
-    },
-  ],
-  invalid: [
-    {
-      code: `
-try {
-	// Some comment
-	if (foo) {
-		bar();
-	}
-} catch (e) {
-	throw e;
-}`,
-      errors: [{ messageId: "noUselessCatchThrow" }],
-      output: `
-// Some comment
-if (foo) {
-	bar();
-}`,
-    },
-  ],
-});
+import { RuleTester } from "@typescript-eslint/rule-tester";
+import { NoUselessCatchThrowRule } from "./no-useless-catch-throw.js";
+
+const ruleTester = new RuleTester();
+
+ruleTester.run("no-useless-catch-throw", NoUselessCatchThrowRule, {
+  valid: [
+    {
+      code: "try { foo(); } catch (e) { console.error(e); }",
+    },
+    {
+      code: 'try { foo(); } catch (e) { throw new Error("Custom error"); }',
+    },
+  ],
+  invalid: [
+    {
+      code: `
+try {
+	// Some comment
+	if (foo) {
+		bar();
+	}
+} catch (e) {
+	throw e;
+}`,
+      errors: [{ messageId: "noUselessCatchThrow" }],
+      output: `
+// Some comment
+if (foo) {
+	bar();
+}`,
+    },
+  ],
+});

package/configs/eslint-config/src/rules/no-useless-catch-throw.ts

@@ -1,47 +1,47 @@
-import { ESLintUtils } from '@typescript-eslint/utils';
-
-export const NoUselessCatchThrowRule = ESLintUtils.RuleCreator.withoutDocs({
-	name: 'no-useless-catch-throw',
-	meta: {
-		type: 'problem',
-		docs: {
-			description: 'Disallow `try-catch` blocks where the `catch` only contains a `throw error`.',
-		},
-		messages: {
-			noUselessCatchThrow: 'Remove useless `catch` block.',
-		},
-		fixable: 'code',
-		schema: [],
-	},
-	defaultOptions: [],
-	create(context) {
-		return {
-			CatchClause(node) {
-				if (
-					node.body.body.length === 1 &&
-					node.body.body[0].type === 'ThrowStatement' &&
-					node.body.body[0].argument.type === 'Identifier' &&
-					node.param?.type === 'Identifier' &&
-					node.body.body[0].argument.name === node.param.name
-				) {
-					context.report({
-						node,
-						messageId: 'noUselessCatchThrow',
-						fix(fixer) {
-							const tryStatement = node.parent;
-							const tryBlock = tryStatement.block;
-							const sourceCode = context.sourceCode;
-							const tryBlockText = sourceCode.getText(tryBlock);
-							const tryBlockTextWithoutBraces = tryBlockText.slice(1, -1).trim();
-							const indentedTryBlockText = tryBlockTextWithoutBraces
-								.split('\n')
-								.map((line) => line.replace(/\t/, ''))
-								.join('\n');
-							return fixer.replaceText(tryStatement, indentedTryBlockText);
-						},
-					});
-				}
-			},
-		};
-	},
-});
+import { ESLintUtils } from '@typescript-eslint/utils';
+
+export const NoUselessCatchThrowRule = ESLintUtils.RuleCreator.withoutDocs({
+	name: 'no-useless-catch-throw',
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Disallow `try-catch` blocks where the `catch` only contains a `throw error`.',
+		},
+		messages: {
+			noUselessCatchThrow: 'Remove useless `catch` block.',
+		},
+		fixable: 'code',
+		schema: [],
+	},
+	defaultOptions: [],
+	create(context) {
+		return {
+			CatchClause(node) {
+				if (
+					node.body.body.length === 1 &&
+					node.body.body[0].type === 'ThrowStatement' &&
+					node.body.body[0].argument.type === 'Identifier' &&
+					node.param?.type === 'Identifier' &&
+					node.body.body[0].argument.name === node.param.name
+				) {
+					context.report({
+						node,
+						messageId: 'noUselessCatchThrow',
+						fix(fixer) {
+							const tryStatement = node.parent;
+							const tryBlock = tryStatement.block;
+							const sourceCode = context.sourceCode;
+							const tryBlockText = sourceCode.getText(tryBlock);
+							const tryBlockTextWithoutBraces = tryBlockText.slice(1, -1).trim();
+							const indentedTryBlockText = tryBlockTextWithoutBraces
+								.split('\n')
+								.map((line) => line.replace(/\t/, ''))
+								.join('\n');
+							return fixer.replaceText(tryStatement, indentedTryBlockText);
+						},
+					});
+				}
+			},
+		};
+	},
+});

package/configs/eslint-config/src/utils/json.ts

@@ -1,21 +1,21 @@
-import type { TSESTree } from '@typescript-eslint/utils';
-
-export const isJsonParseCall = (node: TSESTree.CallExpression) =>
-	node.callee.type === 'MemberExpression' &&
-	node.callee.object.type === 'Identifier' &&
-	node.callee.object.name === 'JSON' &&
-	node.callee.property.type === 'Identifier' &&
-	node.callee.property.name === 'parse';
-
-export const isJsonStringifyCall = (node: TSESTree.CallExpression) => {
-	const parseArg = node.arguments?.[0];
-	return (
-		parseArg !== undefined &&
-		parseArg.type === 'CallExpression' &&
-		parseArg.callee.type === 'MemberExpression' &&
-		parseArg.callee.object.type === 'Identifier' &&
-		parseArg.callee.object.name === 'JSON' &&
-		parseArg.callee.property.type === 'Identifier' &&
-		parseArg.callee.property.name === 'stringify'
-	);
-};
+import type { TSESTree } from '@typescript-eslint/utils';
+
+export const isJsonParseCall = (node: TSESTree.CallExpression) =>
+	node.callee.type === 'MemberExpression' &&
+	node.callee.object.type === 'Identifier' &&
+	node.callee.object.name === 'JSON' &&
+	node.callee.property.type === 'Identifier' &&
+	node.callee.property.name === 'parse';
+
+export const isJsonStringifyCall = (node: TSESTree.CallExpression) => {
+	const parseArg = node.arguments?.[0];
+	return (
+		parseArg !== undefined &&
+		parseArg.type === 'CallExpression' &&
+		parseArg.callee.type === 'MemberExpression' &&
+		parseArg.callee.object.type === 'Identifier' &&
+		parseArg.callee.object.name === 'JSON' &&
+		parseArg.callee.property.type === 'Identifier' &&
+		parseArg.callee.property.name === 'stringify'
+	);
+};

package/package.json

@@ -1,36 +1,35 @@
 {
-	"name": "startx",
-	"version": "0.1.5",
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/avinashid/startx.git"
-	},
-	"bin": {
-		"startx": "./packages/cli/dist/index.mjs"
-	},
-	"scripts": {
-		"dev": "turbo dev",
-		"build": "turbo build",
-		"start": "turbo start",
-		"startx": "node ./packages/cli/dist/index.mjs",
-		"backend": "turbo dev --filter=core-server -- ",
-		"cli": "turbo dev --filter=cli -- ",
-		"lint": "turbo lint",
-		"typecheck": "turbo typecheck",
-		"clean": "turbo clean",
-		"test": "turbo test",
-		"format": "turbo format"
-	},
-	"engines": {
-		"node": ">=22"
-	},
-	"keywords": [
-		"startx",
-		"turborepo",
-		"scaffold",
-		"express"
-	],
-	"author": "avinashid",
-	"license": "MIT",
-	"packageManager": "pnpm@10.28.2"
-}
+  "name": "startx",
+  "version": "0.2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/avinashid/startx.git"
+  },
+  "bin": {
+    "startx": "./packages/cli/dist/index.mjs"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "keywords": [
+    "startx",
+    "turborepo",
+    "scaffold",
+    "express"
+  ],
+  "author": "avinashid",
+  "license": "MIT",
+  "scripts": {
+    "dev": "turbo dev",
+    "build": "turbo build",
+    "start": "turbo start",
+    "startx": "node ./packages/cli/dist/index.mjs",
+    "backend": "turbo dev --filter=core-server -- ",
+    "cli": "turbo dev --filter=cli -- ",
+    "lint": "turbo lint",
+    "typecheck": "turbo typecheck",
+    "clean": "turbo clean",
+    "test": "turbo test",
+    "format": "turbo format"
+  }
+}

package/packages/@repo/constants/src/api.ts

@@ -1 +1 @@
-export const BASE_API_URL = '';
+export const BASE_API_URL = '';

package/packages/@repo/constants/src/time.ts

@@ -1,23 +1,23 @@
-/**
- * Convert time from any time unit to any other unit
- */
-export const Time = {
-	milliseconds: {
-		toMinutes: 1 / (60 * 1000),
-		toSeconds: 1 / 1000,
-	},
-	seconds: {
-		toMilliseconds: 1000,
-	},
-	minutes: {
-		toMilliseconds: 60 * 1000,
-	},
-	hours: {
-		toMilliseconds: 60 * 60 * 1000,
-		toSeconds: 60 * 60,
-	},
-	days: {
-		toSeconds: 24 * 60 * 60,
-		toMilliseconds: 24 * 60 * 60 * 1000,
-	},
-};
+/**
+ * Convert time from any time unit to any other unit
+ */
+export const Time = {
+	milliseconds: {
+		toMinutes: 1 / (60 * 1000),
+		toSeconds: 1 / 1000,
+	},
+	seconds: {
+		toMilliseconds: 1000,
+	},
+	minutes: {
+		toMilliseconds: 60 * 1000,
+	},
+	hours: {
+		toMilliseconds: 60 * 60 * 1000,
+		toSeconds: 60 * 60,
+	},
+	days: {
+		toSeconds: 24 * 60 * 60,
+		toMilliseconds: 24 * 60 * 60 * 1000,
+	},
+};

package/packages/@repo/db/src/schema/index.ts

@@ -1 +1 @@
-export * from "./common.js";
+export * from "./common.js";

package/packages/@repo/lib/src/error-handlers-module/index.ts

@@ -1,11 +1,11 @@
-/**
- * @description Custom error class that extends the built-in Error class for error responses
- */
-export class ErrorResponse extends Error {
-  constructor(public message: string, public statusCode: number) {
-    super(message); // Call the parent constructor with the message
-
-    // Set the prototype chain explicitly for older environments (optional)
-    Object.setPrototypeOf(this, ErrorResponse.prototype);
-  }
-}
+/**
+ * @description Custom error class that extends the built-in Error class for error responses
+ */
+export class ErrorResponse extends Error {
+  constructor(public message: string, public statusCode: number) {
+    super(message); // Call the parent constructor with the message
+
+    // Set the prototype chain explicitly for older environments (optional)
+    Object.setPrototypeOf(this, ErrorResponse.prototype);
+  }
+}