@hypequery/cli 1.1.1 → 1.2.0

package/dist/generators/clickhouse.d.ts

@@ -1,9 +1,9 @@
+import { clickhouseToTsType } from '@hypequery/clickhouse/cli';
 export interface ClickHouseGeneratorOptions {
     outputPath: string;
     includeTables?: string[];
     excludeTables?: string[];
 }
-declare const clickhouseToTsType: (type: string) => string;
 export { clickhouseToTsType };
 export declare function generateClickHouseTypes(options: ClickHouseGeneratorOptions): Promise<void>;
 //# sourceMappingURL=clickhouse.d.ts.map

package/dist/generators/clickhouse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clickhouse.d.ts","sourceRoot":"","sources":["../../src/generators/clickhouse.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,0BAA0B;IACzC,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;CAC1B;AAmGD,QAAA,MAAM,kBAAkB,GAAI,MAAM,MAAM,KAAG,MAsC1C,CAAC;AAEF,OAAO,EAAE,kBAAkB,EAAE,CAAC;AAgC9B,wBAAsB,uBAAuB,CAAC,OAAO,EAAE,0BAA0B,iBA0ChF"}
+{"version":3,"file":"clickhouse.d.ts","sourceRoot":"","sources":["../../src/generators/clickhouse.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAGnB,MAAM,2BAA2B,CAAC;AAGnC,MAAM,WAAW,0BAA0B;IACzC,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED,OAAO,EAAE,kBAAkB,EAAE,CAAC;AAE9B,wBAAsB,uBAAuB,CAAC,OAAO,EAAE,0BAA0B,iBAUhF"}

package/dist/generators/clickhouse.js

@@ -1,272 +1,13 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-import fs from 'node:fs/promises';
-import path from 'node:path';
+import { clickhouseToTsType, generateTypes, } from '@hypequery/clickhouse/cli';
 import { getClickHouseClient } from '../utils/clickhouse-client.js';
-var DEFAULT_WARNING = 'Warning: No tables match the filter criteria. Check your include/exclude options.';
-var capitalizeFirstLetter = function (value) { return value.charAt(0).toUpperCase() + value.slice(1); };
-function splitTopLevelArgs(value) {
-    var parts = [];
-    var current = '';
-    var depth = 0;
-    for (var _i = 0, value_1 = value; _i < value_1.length; _i++) {
-        var char = value_1[_i];
-        if (char === '(') {
-            depth += 1;
-            current += char;
-            continue;
-        }
-        if (char === ')') {
-            depth -= 1;
-            current += char;
-            continue;
-        }
-        if (char === ',' && depth === 0) {
-            parts.push(current.trim());
-            current = '';
-            continue;
-        }
-        current += char;
-    }
-    if (current.trim()) {
-        parts.push(current.trim());
-    }
-    return parts;
-}
-function unwrapType(type, wrapperName) {
-    var prefix = "".concat(wrapperName, "(");
-    return type.startsWith(prefix) && type.endsWith(')') ? type.slice(prefix.length, -1) : null;
-}
-function getPrimitiveTsType(type) {
-    var lowerType = type.toLowerCase();
-    switch (lowerType) {
-        case 'string':
-        case 'uuid':
-            return 'string';
-        case 'int8':
-        case 'int16':
-        case 'int32':
-        case 'uint8':
-        case 'uint16':
-        case 'uint32':
-            return 'number';
-        case 'int64':
-        case 'uint64':
-        case 'uint128':
-        case 'uint256':
-        case 'int128':
-        case 'int256':
-            return 'string';
-        case 'float32':
-        case 'float64':
-        case 'decimal':
-            return 'number';
-        case 'datetime':
-        case 'datetime64':
-        case 'date':
-        case 'date32':
-            return 'string';
-        case 'bool':
-        case 'boolean':
-            return 'boolean';
-        default:
-            if (type.startsWith('FixedString('))
-                return 'string';
-            if (type.startsWith('Decimal('))
-                return 'number';
-            if (type.startsWith('DateTime64('))
-                return 'string';
-            if (type.startsWith('DateTime('))
-                return 'string';
-            if (type.startsWith('Enum8('))
-                return 'string';
-            if (type.startsWith('Enum16('))
-                return 'string';
-            return null;
-    }
-}
-var clickhouseToTsType = function (type) {
-    var wrappedArrayType = unwrapType(type, 'Array');
-    if (wrappedArrayType) {
-        return "Array<".concat(clickhouseToTsType(wrappedArrayType), ">");
-    }
-    var wrappedNullableType = unwrapType(type, 'Nullable');
-    if (wrappedNullableType) {
-        return "".concat(clickhouseToTsType(wrappedNullableType), " | null");
-    }
-    var wrappedLowCardinalityType = unwrapType(type, 'LowCardinality');
-    if (wrappedLowCardinalityType) {
-        return clickhouseToTsType(wrappedLowCardinalityType);
-    }
-    var wrappedTupleType = unwrapType(type, 'Tuple');
-    if (wrappedTupleType) {
-        var tupleParts = splitTopLevelArgs(wrappedTupleType);
-        return "[".concat(tupleParts.map(clickhouseToTsType).join(', '), "]");
-    }
-    var wrappedMapType = unwrapType(type, 'Map');
-    if (wrappedMapType) {
-        var mapParts = splitTopLevelArgs(wrappedMapType);
-        if (mapParts.length === 2) {
-            var valueType = mapParts[1];
-            // JSON object keys are strings even when ClickHouse map keys are numeric.
-            return "Record<string, ".concat(clickhouseToTsType(valueType), ">");
-        }
-        return 'Record<string, unknown>';
-    }
-    var primitiveType = getPrimitiveTsType(type);
-    if (primitiveType)
-        return primitiveType;
-    // Unsupported or more complex ClickHouse types currently preserve the historical fallback.
-    return 'string';
-};
 export { clickhouseToTsType };
-function fetchTables(includeTables, excludeTables) {
-    return __awaiter(this, void 0, void 0, function () {
-        var client, tablesQuery, tables;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    client = getClickHouseClient();
-                    return [4 /*yield*/, client.query({
-                            query: 'SHOW TABLES',
-                            format: 'JSONEachRow',
-                        })];
-                case 1:
-                    tablesQuery = _a.sent();
-                    return [4 /*yield*/, tablesQuery.json()];
-                case 2:
-                    tables = (_a.sent());
-                    if (includeTables === null || includeTables === void 0 ? void 0 : includeTables.length) {
-                        tables = tables.filter(function (table) { return includeTables.includes(table.name); });
-                    }
-                    if (excludeTables === null || excludeTables === void 0 ? void 0 : excludeTables.length) {
-                        tables = tables.filter(function (table) { return !excludeTables.includes(table.name); });
-                    }
-                    return [2 /*return*/, tables];
-            }
-        });
-    });
-}
-function fetchColumns(table) {
-    return __awaiter(this, void 0, void 0, function () {
-        var client, columnsQuery;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    client = getClickHouseClient();
-                    return [4 /*yield*/, client.query({
-                            query: "DESCRIBE TABLE ".concat(table),
-                            format: 'JSONEachRow',
-                        })];
-                case 1:
-                    columnsQuery = _a.sent();
-                    return [4 /*yield*/, columnsQuery.json()];
-                case 2: return [2 /*return*/, (_a.sent())];
-            }
-        });
-    });
-}
-export function generateClickHouseTypes(options) {
-    return __awaiter(this, void 0, void 0, function () {
-        var outputPath, includeTables, excludeTables, tables, typeDefinitions, _i, tables_1, table, columns, _a, columns_1, column, clickHouseType, _b, tables_2, table, columns, _c, columns_2, column, tsType, outputDir;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
-                case 0:
-                    outputPath = options.outputPath, includeTables = options.includeTables, excludeTables = options.excludeTables;
-                    return [4 /*yield*/, fetchTables(includeTables, excludeTables)];
-                case 1:
-                    tables = _d.sent();
-                    if (tables.length === 0) {
-                        console.warn(DEFAULT_WARNING);
-                    }
-                    typeDefinitions = "// Generated by hypequery\n" +
-                        "// This file defines TypeScript types based on your ClickHouse database schema\n\n" +
-                        "export interface IntrospectedSchema {";
-                    _i = 0, tables_1 = tables;
-                    _d.label = 2;
-                case 2:
-                    if (!(_i < tables_1.length)) return [3 /*break*/, 5];
-                    table = tables_1[_i];
-                    return [4 /*yield*/, fetchColumns(table.name)];
-                case 3:
-                    columns = _d.sent();
-                    typeDefinitions += "\n  ".concat(table.name, ": {");
-                    for (_a = 0, columns_1 = columns; _a < columns_1.length; _a++) {
-                        column = columns_1[_a];
-                        clickHouseType = column.type.replace(/'/g, "\\'");
-                        typeDefinitions += "\n    '".concat(column.name, "': '").concat(clickHouseType, "';");
-                    }
-                    typeDefinitions += '\n  };';
-                    _d.label = 4;
-                case 4:
-                    _i++;
-                    return [3 /*break*/, 2];
-                case 5:
-                    typeDefinitions += '\n}\n';
-                    typeDefinitions += "\n// Type-safe record types for each table\n";
-                    _b = 0, tables_2 = tables;
-                    _d.label = 6;
-                case 6:
-                    if (!(_b < tables_2.length)) return [3 /*break*/, 9];
-                    table = tables_2[_b];
-                    return [4 /*yield*/, fetchColumns(table.name)];
-                case 7:
-                    columns = _d.sent();
-                    typeDefinitions += "export interface ".concat(capitalizeFirstLetter(table.name), "Record {");
-                    for (_c = 0, columns_2 = columns; _c < columns_2.length; _c++) {
-                        column = columns_2[_c];
-                        tsType = clickhouseToTsType(column.type).replace(/'/g, '');
-                        typeDefinitions += "\n  '".concat(column.name, "': ").concat(tsType, ";");
-                    }
-                    typeDefinitions += '\n}\n\n';
-                    _d.label = 8;
-                case 8:
-                    _b++;
-                    return [3 /*break*/, 6];
-                case 9:
-                    outputDir = path.dirname(path.resolve(outputPath));
-                    return [4 /*yield*/, fs.mkdir(outputDir, { recursive: true })];
-                case 10:
-                    _d.sent();
-                    return [4 /*yield*/, fs.writeFile(path.resolve(outputPath), typeDefinitions)];
-                case 11:
-                    _d.sent();
-                    return [2 /*return*/];
-            }
-        });
-    });
+export async function generateClickHouseTypes(options) {
+    const generatorOptions = {
+        client: getClickHouseClient(),
+        generatedBy: 'hypequery',
+        includeUsageExample: false,
+        ...(options.includeTables ? { includeTables: options.includeTables } : {}),
+        ...(options.excludeTables ? { excludeTables: options.excludeTables } : {}),
+    };
+    await generateTypes(options.outputPath, generatorOptions);
 }

package/dist/generators/dataset-generator.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Dataset Generator
+ *
+ * Generates dataset DSL code from ClickHouse schema introspection.
+ * This reduces quickstart friction by auto-scaffolding dataset definitions.
+ */
+export interface DatasetGeneratorOptions {
+    outputPath: string;
+    includeTables?: string[];
+    excludeTables?: string[];
+}
+/**
+ * Generate dataset definitions from ClickHouse schema
+ */
+export declare function generateDatasets(options: DatasetGeneratorOptions): Promise<void>;
+//# sourceMappingURL=dataset-generator.d.ts.map

package/dist/generators/dataset-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataset-generator.d.ts","sourceRoot":"","sources":["../../src/generators/dataset-generator.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;CAC1B;AA6MD;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,iBAyDtE"}

package/dist/generators/dataset-generator.js

@@ -0,0 +1,213 @@
+/**
+ * Dataset Generator
+ *
+ * Generates dataset DSL code from ClickHouse schema introspection.
+ * This reduces quickstart friction by auto-scaffolding dataset definitions.
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import { getClickHouseClient } from '../utils/clickhouse-client.js';
+/**
+ * Determine the dataset dimension type from a ClickHouse type
+ */
+function clickhouseToDimensionType(chType) {
+    const normalized = chType.toLowerCase();
+    // String types
+    if (normalized.includes('string') || normalized.includes('enum')) {
+        return 'string';
+    }
+    // Numeric types
+    if (normalized.includes('int') ||
+        normalized.includes('float') ||
+        normalized.includes('double') ||
+        normalized.includes('decimal')) {
+        return 'number';
+    }
+    // Date/Time types
+    if (normalized.includes('date') || normalized.includes('datetime')) {
+        return 'timestamp';
+    }
+    // Boolean
+    if (normalized.includes('bool')) {
+        return 'boolean';
+    }
+    // Default to string for unknown types
+    return 'string';
+}
+/**
+ * Check if a column is likely a timestamp column
+ */
+function isTimestampColumn(column) {
+    const name = column.name.toLowerCase();
+    const type = column.type.toLowerCase();
+    return (type.includes('date') ||
+        type.includes('datetime') ||
+        name.includes('timestamp') ||
+        name.includes('_at') ||
+        name === 'created' ||
+        name === 'updated');
+}
+/**
+ * Check if a column is likely a tenant ID column
+ */
+function isTenantColumn(column) {
+    const name = column.name.toLowerCase();
+    return (name === 'tenant_id' ||
+        name === 'organization_id' ||
+        name === 'org_id' ||
+        name === 'account_id' ||
+        name === 'customer_id');
+}
+/**
+ * Check if a column is numeric and suitable for measures
+ */
+function isNumericColumn(column) {
+    const type = column.type.toLowerCase();
+    return (type.includes('int') ||
+        type.includes('float') ||
+        type.includes('double') ||
+        type.includes('decimal'));
+}
+/**
+ * Convert table name to PascalCase for dataset variable name
+ */
+function tableToPascalCase(tableName) {
+    return tableName
+        .split('_')
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join('');
+}
+/**
+ * Convert column name to camelCase for field name
+ */
+function columnToCamelCase(columnName) {
+    const parts = columnName.split('_');
+    return parts[0] + parts.slice(1).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join('');
+}
+/**
+ * Generate a human-readable label from a column name
+ */
+function generateLabel(columnName) {
+    return columnName
+        .split('_')
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ');
+}
+/**
+ * Generate dataset definition code for a single table
+ */
+async function generateDatasetForTable(client, tableName) {
+    // Get column information
+    const columnsQuery = await client.query({
+        query: `DESCRIBE TABLE ${tableName}`,
+        format: 'JSONEachRow',
+    });
+    const columns = await columnsQuery.json();
+    // Determine timeKey (prefer created_at, then any timestamp column)
+    const timestampColumns = columns.filter(isTimestampColumn);
+    const timeKeyColumn = timestampColumns.find((c) => c.name === 'created_at') || timestampColumns[0];
+    // Determine tenantKey
+    const tenantColumn = columns.find(isTenantColumn);
+    // Generate dimensions
+    const dimensionLines = [];
+    for (const column of columns) {
+        const fieldName = columnToCamelCase(column.name);
+        const dimensionType = clickhouseToDimensionType(column.type);
+        const label = generateLabel(column.name);
+        // Skip if column name === fieldName (no transformation needed)
+        if (column.name === fieldName) {
+            dimensionLines.push(`    ${fieldName}: dimension.${dimensionType}({ label: '${label}' }),`);
+        }
+        else {
+            dimensionLines.push(`    ${fieldName}: dimension.${dimensionType}({ column: '${column.name}', label: '${label}' }),`);
+        }
+    }
+    // Generate measures (for numeric columns only)
+    const numericColumns = columns.filter(isNumericColumn).filter((c) => !isTenantColumn(c));
+    const measureLines = [];
+    if (numericColumns.length > 0) {
+        measureLines.push(`    // Count measures`);
+        measureLines.push(`    totalCount: measure.count('${columnToCamelCase(columns[0].name)}', { label: 'Total Count' }),`);
+        measureLines.push(``);
+        for (const column of numericColumns) {
+            const fieldName = columnToCamelCase(column.name);
+            const label = generateLabel(column.name);
+            measureLines.push(`    // ${label} measures`);
+            measureLines.push(`    total${tableToPascalCase(column.name)}: measure.sum('${fieldName}', { label: 'Total ${label}' }),`);
+            measureLines.push(`    avg${tableToPascalCase(column.name)}: measure.avg('${fieldName}', { label: 'Average ${label}' }),`);
+            measureLines.push(``);
+        }
+    }
+    else {
+        measureLines.push(`    totalCount: measure.count('${columnToCamelCase(columns[0].name)}', { label: 'Total Count' }),`);
+    }
+    // Build the dataset definition
+    const datasetName = tableToPascalCase(tableName);
+    const configLines = [];
+    configLines.push(`  source: '${tableName}',`);
+    if (timeKeyColumn) {
+        configLines.push(`  timeKey: '${timeKeyColumn.name}',`);
+    }
+    if (tenantColumn) {
+        configLines.push(`  tenantKey: '${tenantColumn.name}', // Auto-detected tenant isolation column`);
+    }
+    configLines.push(`  dimensions: {`);
+    configLines.push(...dimensionLines);
+    configLines.push(`  },`);
+    configLines.push(`  measures: {`);
+    configLines.push(...measureLines);
+    configLines.push(`  },`);
+    return `export const ${datasetName}Dataset = dataset('${tableName}', {
+${configLines.join('\n')}
+});
+`;
+}
+/**
+ * Generate dataset definitions from ClickHouse schema
+ */
+export async function generateDatasets(options) {
+    const client = getClickHouseClient();
+    // Get all tables
+    const tablesQuery = await client.query({
+        query: 'SHOW TABLES',
+        format: 'JSONEachRow',
+    });
+    let tables = await tablesQuery.json();
+    // Filter tables
+    if (options.includeTables && options.includeTables.length > 0) {
+        tables = tables.filter((table) => options.includeTables.includes(table.name));
+    }
+    if (options.excludeTables && options.excludeTables.length > 0) {
+        tables = tables.filter((table) => !options.excludeTables.includes(table.name));
+    }
+    // Filter out system tables
+    tables = tables.filter((table) => !table.name.startsWith('system.') && !table.name.startsWith('.inner'));
+    if (tables.length === 0) {
+        throw new Error('No tables found matching the specified criteria');
+    }
+    // Generate dataset definitions
+    const datasetDefinitions = [];
+    for (const table of tables) {
+        const datasetCode = await generateDatasetForTable(client, table.name);
+        datasetDefinitions.push(datasetCode);
+    }
+    // Build the complete output file
+    const header = `// Generated by @hypequery/cli
+// This file defines dataset definitions based on your ClickHouse database schema
+
+import { dataset, dimension, measure } from '@hypequery/datasets';
+
+`;
+    const footer = `
+// Export all datasets as a registry
+export const datasets = {
+${tables.map((table) => `  ${table.name}: ${tableToPascalCase(table.name)}Dataset,`).join('\n')}
+};
+`;
+    const output = header + datasetDefinitions.join('\n') + footer;
+    // Ensure output directory exists
+    const outputDir = path.dirname(path.resolve(options.outputPath));
+    await fs.mkdir(outputDir, { recursive: true });
+    // Write the file
+    await fs.writeFile(path.resolve(options.outputPath), output);
+}

package/dist/generators/index.js

@@ -1,13 +1,13 @@
 import { generateClickHouseTypes } from './clickhouse.js';
-var generators = {
+const generators = {
     clickhouse: generateClickHouseTypes,
 };
 export function getTypeGenerator(dbType) {
-    var generator = generators[dbType];
+    const generator = generators[dbType];
     if (!generator) {
         throw new Error(dbType === 'unknown'
-            ? 'Unable to detect database type. Re-run `hypequery init --database <type>` or pass `--database` explicitly.'
-            : "Type generation for ".concat(dbType, " is not supported yet."));
+            ? 'Unable to detect database type. Re-run `hypequery generate --database <type>` or pass `--database` explicitly.'
+            : `Type generation for ${dbType} is not supported yet.`);
     }
     return generator;
 }

package/dist/templates/api.d.ts

@@ -0,0 +1,9 @@
+import { type AuthTemplateMode } from './auth-scaffold.js';
+export type { AuthTemplateMode };
+/**
+ * Generate api.ts file for the semantic datasets API.
+ */
+export declare function generateApiTemplate(options?: {
+    auth?: AuthTemplateMode;
+}): string;
+//# sourceMappingURL=api.d.ts.map

package/dist/templates/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../src/templates/api.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,gBAAgB,EAGtB,MAAM,oBAAoB,CAAC;AAE5B,YAAY,EAAE,gBAAgB,EAAE,CAAC;AAEjC;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,GAAE;IAAE,IAAI,CAAC,EAAE,gBAAgB,CAAA;CAAO,GAAG,MAAM,CAsBrF"}

package/dist/templates/api.js

@@ -0,0 +1,26 @@
+import { hostUserHelpers, contextAuthConfig, } from './auth-scaffold.js';
+/**
+ * Generate api.ts file for the semantic datasets API.
+ */
+export function generateApiTemplate(options = {}) {
+    const authMode = options.auth ?? 'none';
+    const serveImports = authMode === 'context' ? 'createAPI, fromContext' : 'createAPI';
+    const authHelpers = authMode === 'context'
+        ? `\n${hostUserHelpers}\n`
+        : '';
+    const authConfig = authMode === 'context'
+        ? `${contextAuthConfig}\n`
+        : '';
+    return `import { ${serveImports} } from '@hypequery/serve';
+import type { InferApiType } from '@hypequery/serve';
+import { db } from './client.js';
+import { datasets } from './datasets.js';
+${authHelpers}
+export const api = createAPI({
+  queryBuilder: db,
+  datasets,
+${authConfig}});
+
+export type ApiDefinition = InferApiType<typeof api>;
+`;
+}

package/dist/templates/auth-scaffold.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Shared auth scaffolding snippets used by the `api.ts` and `queries.ts`
+ * templates so the generated code stays identical across scaffold styles.
+ */
+export type AuthTemplateMode = 'none' | 'context';
+/**
+ * Type guards that pull a trusted `HostUser` off the underlying request. The
+ * host framework is expected to have already authenticated the request and
+ * attached the user to `request.raw.user`.
+ */
+export declare const hostUserHelpers = "type HostUser = {\n  id: string;\n  orgId: string;\n  roles?: string[];\n};\n\nconst isRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === 'object' && value !== null;\n\nconst isHostUser = (value: unknown): value is HostUser => {\n  if (!isRecord(value)) return false;\n  const roles = value.roles;\n  return typeof value.id === 'string' &&\n    typeof value.orgId === 'string' &&\n    (roles === undefined || (Array.isArray(roles) && roles.every((role) => typeof role === 'string')));\n};\n\nconst getUserFromRequest = (raw: unknown): HostUser | null => {\n  const user = isRecord(raw) ? raw.user : null;\n  return isHostUser(user) ? user : null;\n};";
+/**
+ * The `auth` + `tenant` config block wired to {@link hostUserHelpers}.
+ * Indented two spaces so it drops straight into the config object literal.
+ */
+export declare const contextAuthConfig = "  auth: fromContext(({ request }) => {\n    const user = getUserFromRequest(request.raw);\n    return user\n      ? { userId: user.id, tenantId: user.orgId, roles: user.roles }\n      : null;\n  }),\n  tenant: {\n    extract: (auth: { tenantId?: string }) => auth.tenantId,\n    column: 'tenant_id',\n    mode: 'auto-inject',\n  },";
+//# sourceMappingURL=auth-scaffold.d.ts.map

package/dist/templates/auth-scaffold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-scaffold.d.ts","sourceRoot":"","sources":["../../src/templates/auth-scaffold.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,SAAS,CAAC;AAElD;;;;GAIG;AACH,eAAO,MAAM,eAAe,+qBAoBzB,CAAC;AAEJ;;;GAGG;AACH,eAAO,MAAM,iBAAiB,gVAUzB,CAAC"}

package/dist/templates/auth-scaffold.js

@@ -0,0 +1,41 @@
+/**
+ * Type guards that pull a trusted `HostUser` off the underlying request. The
+ * host framework is expected to have already authenticated the request and
+ * attached the user to `request.raw.user`.
+ */
+export const hostUserHelpers = `type HostUser = {
+  id: string;
+  orgId: string;
+  roles?: string[];
+};
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null;
+
+const isHostUser = (value: unknown): value is HostUser => {
+  if (!isRecord(value)) return false;
+  const roles = value.roles;
+  return typeof value.id === 'string' &&
+    typeof value.orgId === 'string' &&
+    (roles === undefined || (Array.isArray(roles) && roles.every((role) => typeof role === 'string')));
+};
+
+const getUserFromRequest = (raw: unknown): HostUser | null => {
+  const user = isRecord(raw) ? raw.user : null;
+  return isHostUser(user) ? user : null;
+};`;
+/**
+ * The `auth` + `tenant` config block wired to {@link hostUserHelpers}.
+ * Indented two spaces so it drops straight into the config object literal.
+ */
+export const contextAuthConfig = `  auth: fromContext(({ request }) => {
+    const user = getUserFromRequest(request.raw);
+    return user
+      ? { userId: user.id, tenantId: user.orgId, roles: user.roles }
+      : null;
+  }),
+  tenant: {
+    extract: (auth: { tenantId?: string }) => auth.tenantId,
+    column: 'tenant_id',
+    mode: 'auto-inject',
+  },`;