@harperfast/schema-codegen 1.0.0 → 1.0.2

package/README.md

@@ -6,8 +6,6 @@ Schema Codegen will generate TypeScript types for your GraphQL schemas, making i
 
 Install this with your favorite package manager!
 
-**Warning**: I haven't actually published this yet. :)
-
 ```bash
 npm install --save @harperfast/schema-codegen
 ```
@@ -89,8 +87,6 @@ declare module 'harperdb' {
 
 ## Development
 
-This code uses type stripping, so as long as you use a compatible version of Node, nothing needs to be compiled.
-
 To use this in an application, first link it:
 
 ```bash

package/config.yaml

@@ -1 +1 @@
-extensionModule: ./extensionModule.ts
+extensionModule: ./extensionModule.js

package/{extensionModule.ts → extensionModule.js}

@@ -1,11 +1,14 @@
-import type { Scope } from 'harperdb';
-import { setLogger } from './utils/logger.ts';
-import { regenerateAll } from './utils/regenerateAll.ts';
-import { sleep } from './utils/sleep.ts';
+/** @typedef {import('harperdb').Scope} Scope */
+import { setLogger } from './utils/logger.js';
+import { regenerateAll } from './utils/regenerateAll.js';
+import { sleep } from './utils/sleep.js';
 
 export const suppressHandleApplicationWarning = true;
 
-export async function handleApplication(scope: Scope) {
+/**
+ * @param {Scope} scope
+ */
+export async function handleApplication(scope) {
 	setLogger(scope.logger);
 
 	if (!process.env.DEV_MODE) {
@@ -15,9 +18,9 @@ export async function handleApplication(scope: Scope) {
 
 	const watchConfig = scope.options.get(['watch']);
 	const shouldWatch = watchConfig === true || watchConfig === undefined;
-	const globalTypes = (scope.options.get(['globalTypes']) as string) || './schema.globalTypes.d.ts';
-	const schemaTypes = (scope.options.get(['schemaTypes']) as string) || './schema.types.ts';
-	const jsdoc = scope.options.get(['jsdoc']) as string | undefined;
+	const globalTypes = /** @type {string} */ (scope.options.get(['globalTypes'])) || './schema.globalTypes.d.ts';
+	const schemaTypes = /** @type {string} */ (scope.options.get(['schemaTypes'])) || './schema.types.ts';
+	const jsdoc = /** @type {string | undefined} */ (scope.options.get(['jsdoc']));
 
 	if (shouldWatch) {
 		scope.on('close', scopeClosed);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@harperfast/schema-codegen",
-	"version": "1.0.0",
+	"version": "1.0.2",
 	"type": "module",
 	"scripts": {
 		"commitlint": "commitlint --edit",
@@ -14,10 +14,10 @@
 		"test:watch": "vitest"
 	},
 	"files": [
-		"extensionModule.ts",
+		"extensionModule.js",
 		"config.yaml",
 		"utils/",
-		"!utils/**/*.test.ts"
+		"!utils/**/*.test.js"
 	],
 	"devDependencies": {
 		"@commitlint/cli": "^20.0.0",

package/utils/collectTables.js

@@ -0,0 +1,20 @@
+/** @typedef {import('harperdb').Table} Table */
+import { databases as hdbDatabases } from 'harperdb';
+
+/**
+ * @returns {(Table & { databaseName: string })[]}
+ */
+export function collectTables() {
+	/** @type {(Table & { databaseName: string })[]} */
+	const tablesList = [];
+	for (const dbName of Object.keys(hdbDatabases || {})) {
+		const tables = hdbDatabases[dbName];
+		for (const tableName of Object.keys(tables || {})) {
+			const TableClass = tables[tableName];
+			if (!TableClass?.attributes) { continue; }
+			TableClass.databaseName = dbName;
+			tablesList.push(/** @type {Table & { databaseName: string }} */ (TableClass));
+		}
+	}
+	return tablesList;
+}

package/utils/{generateInterface.ts → generateInterface.js}

@@ -1,9 +1,12 @@
-import type { Table } from 'harperdb';
-import { isNullable } from './isNullable.ts';
-import { mapType } from './mapType.ts';
-import { singularize } from './singularize.ts';
+/** @typedef {import('harperdb').Table} Table */
+import { isNullable } from './isNullable.js';
+import { mapType } from './mapType.js';
+import { singularize } from './singularize.js';
 
-export function generateInterface(table: Table & { databaseName?: string }) {
+/**
+ * @param {Table & { databaseName?: string }} table
+ */
+export function generateInterface(table) {
 	const pluralRaw = table.tableName;
 	const singularRaw = singularize(pluralRaw);
 	const dbPrefix = table.databaseName && table.databaseName !== 'data' ? `${table.databaseName}_` : '';
@@ -12,14 +15,15 @@ export function generateInterface(table: Table & { databaseName?: string }) {
 	const isDifferent = plural !== singular;
 
 	let code = `\nexport interface ${singular} {\n`;
-	const primaryKeys: string[] = [];
+	/** @type {string[]} */
+	const primaryKeys = [];
 	for (const attribute of table.attributes || []) {
 		const type = mapType(attribute);
 		const primaryKey = !!attribute.isPrimaryKey;
 		const nullable = !primaryKey && isNullable(attribute);
 		code += `\t${attribute.name}${nullable ? '?' : ''}: ${type};\n`;
 		if (primaryKey) {
-			primaryKeys.push(attribute.name!);
+			primaryKeys.push(attribute.name);
 		}
 	}
 	code += `}\n\n`;

package/utils/{generateJSDoc.ts → generateJSDoc.js}

@@ -1,7 +1,7 @@
-import type { Table } from 'harperdb';
-import { isNullable } from './isNullable.ts';
-import { mapType } from './mapType.ts';
-import { singularize } from './singularize.ts';
+/** @typedef {import('harperdb').Table} Table */
+import { isNullable } from './isNullable.js';
+import { mapType } from './mapType.js';
+import { singularize } from './singularize.js';
 
 /**
  * Generates JSDoc types for a given HarperDB table.
@@ -13,8 +13,10 @@ import { singularize } from './singularize.ts';
  *  * @property {string} name
  *  * @property {any} [mp3]
  *  *\/
+ *
+ * @param {Table & { databaseName?: string }} table
  */
-export function generateJSDoc(table: Table & { databaseName?: string }) {
+export function generateJSDoc(table) {
 	const pluralRaw = table.tableName;
 	const singularRaw = singularize(pluralRaw);
 	const dbPrefix = table.databaseName && table.databaseName !== 'data' ? `${table.databaseName}_` : '';
@@ -23,14 +25,14 @@ export function generateJSDoc(table: Table & { databaseName?: string }) {
 	const isDifferent = plural !== singular;
 
 	let code = `\n/**\n * @typedef {Object} ${singular}\n`;
-	const primaryKeys: string[] = [];
+	const primaryKeys = [];
 	for (const attribute of table.attributes || []) {
 		const type = mapType(attribute);
 		const primaryKey = !!attribute.isPrimaryKey;
 		const nullable = !primaryKey && isNullable(attribute);
 		code += ` * @property {${type}} ${nullable ? '[' : ''}${attribute.name}${nullable ? ']' : ''}\n`;
 		if (primaryKey) {
-			primaryKeys.push(attribute.name!);
+			primaryKeys.push(attribute.name);
 		}
 	}
 	code += ` */\n\n`;

package/utils/{generateJSDocFromTables.ts → generateJSDocFromTables.js}

@@ -1,18 +1,23 @@
-import type { Table } from 'harperdb';
-import { generateJSDoc } from './generateJSDoc.ts';
-import { singularize } from './singularize.ts';
-import type { TableMeta } from './tableMeta.ts';
+/** @typedef {import('harperdb').Table} Table */
+/** @import { TableMeta } from './tableMeta.js' */
+import { generateJSDoc } from './generateJSDoc.js';
+import { singularize } from './singularize.js';
 
+/**
+ * @param {(Table & { databaseName: string })[]} tablesInput
+ * @param {string} label
+ */
 export function generateJSDocFromTables(
-	tablesInput: (Table & { databaseName: string })[],
-	label: string = 'HarperDB schemas',
+	tablesInput,
+	label = 'HarperDB schemas',
 ) {
 	let jsCode = `/**
  Generated from ${label}
  Manual changes will be lost!
  > harper dev .
  */`;
-	const tables: TableMeta[] = [];
+	/** @type {TableMeta[]} */
+	const tables = [];
 
 	for (const table of tablesInput) {
 		jsCode += generateJSDoc(table);

package/utils/{generateTS.ts → generateTS.js}

@@ -1,18 +1,24 @@
-import type { Table } from 'harperdb';
-import { generateInterface } from './generateInterface.ts';
-import { singularize } from './singularize.ts';
-import type { TableMeta } from './tableMeta.ts';
+/** @typedef {import('harperdb').Table} Table */
+/** @import { TableMeta } from './tableMeta.js' */
+import { generateInterface } from './generateInterface.js';
+import { singularize } from './singularize.js';
 
+/**
+ * @param {(Table & { databaseName: string })[]} tablesInput
+ * @param {string} label
+ * @returns {{ tsCode: string, tables: TableMeta[] }}
+ */
 export function generateTSFromTables(
-	tablesInput: (Table & { databaseName: string })[],
-	label: string = 'HarperDB schemas',
+	tablesInput,
+	label = 'HarperDB schemas',
 ) {
 	let tsCode = `/**
  Generated from ${label}
  Manual changes will be lost!
  > harper dev .
  */`;
-	const tables: TableMeta[] = [];
+	/** @type {TableMeta[]} */
+	const tables = [];
 
 	for (const table of tablesInput) {
 		tsCode += generateInterface(table);

package/utils/{generateTablesDTS.ts → generateTablesDTS.js}

@@ -1,9 +1,14 @@
+/** @import { TableMeta } from './tableMeta.js' */
 import fs from 'fs';
 import path from 'path';
-import { getLogger } from './logger.ts';
-import type { TableMeta } from './tableMeta.ts';
+import { getLogger } from './logger.js';
 
-export function generateTablesDTS(globalTypesPath: string, schemaTypesPath: string, tables: TableMeta[]) {
+/**
+ * @param {string} globalTypesPath
+ * @param {string} schemaTypesPath
+ * @param {TableMeta[]} tables
+ */
+export function generateTablesDTS(globalTypesPath, schemaTypesPath, tables) {
 	let content = `/**
  Generated from your schema files
  Manual changes will be lost!
@@ -12,7 +17,8 @@ export function generateTablesDTS(globalTypesPath: string, schemaTypesPath: stri
 `;
 	content += `import type { Table } from 'harperdb';\n`;
 	// Build a single import of all relevant types from schemaTypesPath
-	const namesToImport = new Set<string>();
+	/** @type {Set<string>} */
+	const namesToImport = new Set();
 	for (const table of tables) {
 		namesToImport.add(table.singular);
 	}
@@ -23,12 +29,14 @@ export function generateTablesDTS(globalTypesPath: string, schemaTypesPath: stri
 	}
 	content += '\n';
 
-	const dbMap = new Map<string, TableMeta[]>();
+	/** @type {Map<string, TableMeta[]>} */
+	const dbMap = new Map();
 	for (const table of tables) {
 		if (!dbMap.has(table.databaseName)) {
-			dbMap.set(table.databaseName, []);
+			dbMap.set(table.databaseName, [table]);
+		} else {
+			dbMap.get(table.databaseName)?.push(table);
 		}
-		dbMap.get(table.databaseName)!.push(table);
 	}
 
 	content += `declare module 'harperdb' {\n`;
@@ -60,6 +68,6 @@ export function generateTablesDTS(globalTypesPath: string, schemaTypesPath: stri
 	const existingContent = fs.existsSync(outPath) && fs.readFileSync(outPath, 'utf8');
 	if (existingContent !== content) {
 		fs.writeFileSync(outPath, content, 'utf8');
-		getLogger().debug?.(`Updated types in ${outPath}`);
+		getLogger()?.debug?.(`Updated types in ${outPath}`);
 	}
 }

package/utils/{isNullable.ts → isNullable.js}

@@ -1,6 +1,9 @@
-import type { Attribute } from 'harperdb';
+/** @typedef {import('harperdb').Attribute} Attribute */
 
-export function isNullable(attribute: Attribute) {
+/**
+ * @param {Attribute} attribute
+ */
+export function isNullable(attribute) {
 	// Primary keys are always required
 	if (attribute.isPrimaryKey) { return false; }
 	return !!attribute.nullable || attribute.nullable === undefined;

package/utils/logger.js

@@ -0,0 +1,18 @@
+/** @typedef {import('harperdb').Logger} Logger */
+
+/** @type {Logger | null} */
+let logger = null;
+
+/**
+ * @param {Logger} newLogger
+ */
+export function setLogger(newLogger) {
+	logger = newLogger;
+}
+
+/**
+ * @returns {Logger | null}
+ */
+export function getLogger() {
+	return logger;
+}

package/utils/{mapType.ts → mapType.js}

@@ -1,7 +1,11 @@
-import type { Attribute } from 'harperdb';
-import { singularize } from './singularize.ts';
+/** @typedef {import('harperdb').Attribute} Attribute */
+import { singularize } from './singularize.js';
 
-function mapObjectType(properties: Attribute[] | undefined): string {
+/**
+ * @param {Attribute[] | undefined} properties
+ * @returns {string}
+ */
+function mapObjectType(properties) {
 	if (!properties || properties.length === 0) { return 'Record<string, any>'; }
 	const fields = properties
 		.map((prop) => {
@@ -12,7 +16,11 @@ function mapObjectType(properties: Attribute[] | undefined): string {
 	return `{ ${fields} }`;
 }
 
-export function mapType(attribute: Attribute): string {
+/**
+ * @param {Attribute} attribute
+ * @returns {string}
+ */
+export function mapType(attribute) {
 	const name = attribute?.type || 'Any';
 	switch (name) {
 		case 'String':

package/utils/{regenerateAll.ts → regenerateAll.js}

@@ -1,12 +1,16 @@
 import path from 'path';
-import { collectTables } from './collectTables.ts';
-import { generateJSDocFromTables } from './generateJSDocFromTables.ts';
-import { generateTablesDTS } from './generateTablesDTS.ts';
-import { generateTSFromTables } from './generateTS.ts';
-import type { TableMeta } from './tableMeta.ts';
-import { writeIfChanged } from './writeIfChanged.ts';
+import { collectTables } from './collectTables.js';
+import { generateJSDocFromTables } from './generateJSDocFromTables.js';
+import { generateTablesDTS } from './generateTablesDTS.js';
+import { generateTSFromTables } from './generateTS.js';
+import { writeIfChanged } from './writeIfChanged.js';
 
-export function regenerateAll(globalTypes: string, schemaTypes: string, jsdoc?: string) {
+/**
+ * @param {string} globalTypes
+ * @param {string} schemaTypes
+ * @param {string} [jsdoc]
+ */
+export function regenerateAll(globalTypes, schemaTypes, jsdoc) {
 	const list = collectTables();
 
 	if (jsdoc) {
@@ -15,6 +19,6 @@ export function regenerateAll(globalTypes: string, schemaTypes: string, jsdoc?:
 	} else {
 		const { tsCode, tables } = generateTSFromTables(list, 'HarperDB schema');
 		writeIfChanged(path.resolve(schemaTypes), tsCode);
-		generateTablesDTS(path.resolve(globalTypes), path.resolve(schemaTypes), tables as TableMeta[]);
+		generateTablesDTS(path.resolve(globalTypes), path.resolve(schemaTypes), tables);
 	}
 }

package/utils/{singularize.ts → singularize.js}

@@ -1,4 +1,8 @@
-export function singularize(word: string): string {
+/**
+ * @param {string} word
+ * @returns {string}
+ */
+export function singularize(word) {
 	const lower = word.toLowerCase();
 
 	// Nouns that are the same in singular and plural or should be treated as unchanged here
@@ -23,7 +27,8 @@ export function singularize(word: string): string {
 	}
 
 	// Irregular plurals not covered by suffix rules
-	const irregular: Record<string, string> = {
+	/** @type {Record<string, string>} */
+	const irregular = {
 		people: 'person',
 		men: 'man',
 		women: 'woman',

package/utils/{sleep.ts → sleep.js}

@@ -1,3 +1,6 @@
-export function sleep(ms: number) {
+/**
+ * @param {number} ms
+ */
+export function sleep(ms) {
 	return new Promise(resolve => setTimeout(resolve, ms));
 }

package/utils/tableMeta.js

@@ -0,0 +1,7 @@
+/**
+ * @typedef {Object} TableMeta
+ * @property {string} singular
+ * @property {string} plural
+ * @property {string} databaseName
+ */
+export {};

package/utils/{writeIfChanged.ts → writeIfChanged.js}

@@ -1,13 +1,17 @@
 import fs from 'fs';
 import path from 'path';
-import { getLogger } from './logger.ts';
+import { getLogger } from './logger.js';
 
-export function writeIfChanged(filePath: string, content: string) {
+/**
+ * @param {string} filePath
+ * @param {string} content
+ */
+export function writeIfChanged(filePath, content) {
 	const dir = path.dirname(filePath);
 	if (!fs.existsSync(dir)) { fs.mkdirSync(dir, { recursive: true }); }
 	const existing = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf8') : undefined;
 	if (existing !== content) {
 		fs.writeFileSync(filePath, content, 'utf8');
-		getLogger().debug?.(`Updated types in ${filePath}`);
+		getLogger()?.debug?.(`Updated types in ${filePath}`);
 	}
 }

package/utils/collectTables.ts

@@ -1,16 +0,0 @@
-import type { Table } from 'harperdb';
-import { databases as hdbDatabases } from 'harperdb';
-
-export function collectTables() {
-	const tablesList: (Table & { databaseName: string })[] = [];
-	for (const dbName of Object.keys(hdbDatabases || {})) {
-		const tables = (hdbDatabases as any)[dbName];
-		for (const tableName of Object.keys(tables || {})) {
-			const TableClass = tables[tableName];
-			if (!TableClass?.attributes) { continue; }
-			(TableClass as any).databaseName = dbName;
-			tablesList.push(TableClass as Table & { databaseName: string });
-		}
-	}
-	return tablesList;
-}

package/utils/logger.ts

@@ -1,11 +0,0 @@
-import type { Logger } from 'harperdb';
-
-let logger: Logger | null = null;
-
-export function setLogger(newLogger: Logger) {
-	logger = newLogger;
-}
-
-export function getLogger(): Logger {
-	return logger!;
-}

package/utils/tableMeta.ts

@@ -1,5 +0,0 @@
-export interface TableMeta {
-	singular: string;
-	plural: string;
-	databaseName: string;
-}