archetype-engine 2.0.0

package/dist/src/manifest.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Manifest definition - collects all entities and settings
+ * @module manifest
+ */
+import { EntityIR } from './entity';
+import { ExternalSourceConfig } from './source';
+/**
+ * Generation mode configuration
+ */
+export interface ModeConfig {
+    /**
+     * 'full' - Generate database schema, API, validation, hooks (default)
+     * 'headless' - Skip database schema, generate validation, hooks, services only
+     * 'api-only' - Generate API layer only (for backend services)
+     */
+    type: 'full' | 'headless' | 'api-only';
+    /**
+     * When headless, optionally specify which generators to include
+     * Default: ['validation', 'hooks', 'services', 'i18n']
+     */
+    include?: ('schema' | 'validation' | 'api' | 'hooks' | 'types' | 'services' | 'i18n')[];
+}
+/**
+ * Normalize mode config from shorthand or full config
+ */
+export declare function normalizeMode(mode?: ModeConfig | 'full' | 'headless' | 'api-only'): ModeConfig;
+/**
+ * Database connection configuration
+ */
+export interface DatabaseConfig {
+    /** Database type */
+    type: 'sqlite' | 'postgres' | 'mysql';
+    /** SQLite file path (for SQLite only) */
+    file?: string;
+    /** Connection URL (for PostgreSQL/MySQL) */
+    url?: string;
+}
+export interface AuthConfig {
+    enabled: boolean;
+    adapter?: 'drizzle';
+    providers?: ('credentials' | 'google' | 'github' | 'discord')[];
+    sessionStrategy?: 'jwt' | 'database';
+}
+export interface I18nConfig {
+    languages: string[];
+    defaultLanguage: string;
+    outputDir?: string;
+}
+export interface ObservabilityConfig {
+    logging?: {
+        enabled: boolean;
+        level?: 'debug' | 'info' | 'warn' | 'error';
+        format?: 'json' | 'pretty';
+    };
+    telemetry?: {
+        enabled: boolean;
+        events?: ('create' | 'update' | 'remove')[];
+    };
+    audit?: {
+        enabled: boolean;
+        entity?: string;
+    };
+}
+export interface TenancyConfig {
+    enabled: boolean;
+    field: string;
+}
+export interface DefaultBehaviors {
+    timestamps?: boolean;
+    softDelete?: boolean;
+    audit?: boolean;
+}
+export interface ManifestDefinition {
+    /** Template ID (e.g., 'nextjs-drizzle-trpc') */
+    template?: string;
+    /**
+     * Generation mode - 'full' | 'headless' | 'api-only' or ModeConfig object
+     * - 'full': Generate database schema, API, validation, hooks (default)
+     * - 'headless': Skip database schema, generate validation, hooks, services only
+     * - 'api-only': Generate API layer only
+     */
+    mode?: ModeConfig | 'full' | 'headless' | 'api-only';
+    /** Entity definitions */
+    entities: EntityIR[];
+    /**
+     * Global default source for all entities.
+     * Individual entities can override this with their own source.
+     */
+    source?: ExternalSourceConfig;
+    /** Database configuration (required for 'full' mode, optional for 'headless') */
+    database?: DatabaseConfig;
+    auth?: AuthConfig;
+    i18n?: I18nConfig;
+    observability?: ObservabilityConfig;
+    tenancy?: TenancyConfig;
+    defaults?: DefaultBehaviors;
+}
+export interface ManifestIR {
+    /** Template ID - CLI validates if provided */
+    template?: string;
+    /** Normalized mode configuration */
+    mode: ModeConfig;
+    /** Entity definitions */
+    entities: EntityIR[];
+    /** Global default source for entities (optional) */
+    source?: ExternalSourceConfig;
+    /** Database configuration (optional for headless mode) */
+    database?: DatabaseConfig;
+    auth: AuthConfig;
+    i18n: I18nConfig;
+    observability: ObservabilityConfig;
+    tenancy: TenancyConfig;
+    defaults: DefaultBehaviors;
+}
+/**
+ * Define a manifest with entities and configuration
+ *
+ * @param definition - Manifest configuration
+ * @returns Compiled ManifestIR for use by CLI and generators
+ *
+ * @example
+ * ```typescript
+ * const manifest = defineManifest({
+ *   template: 'nextjs-drizzle-trpc',
+ *   entities: [User, Post],
+ *   database: { type: 'sqlite', file: './sqlite.db' },
+ * })
+ * ```
+ */
+export declare function defineManifest(definition: ManifestDefinition): ManifestIR;
+/**
+ * Alias for defineManifest - use in archetype.config.ts
+ *
+ * @example
+ * ```typescript
+ * // archetype.config.ts
+ * import { defineConfig } from 'archetype-engine'
+ *
+ * export default defineConfig({
+ *   template: 'nextjs-drizzle-trpc',
+ *   entities: [User, Post],
+ *   database: { type: 'postgres', url: process.env.DATABASE_URL },
+ * })
+ * ```
+ */
+export declare const defineConfig: typeof defineManifest;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/src/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../src/manifest.ts"],"names":[],"mappings":"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"}

package/dist/src/manifest.js

@@ -0,0 +1,104 @@
+"use strict";
+/**
+ * Manifest definition - collects all entities and settings
+ * @module manifest
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineConfig = void 0;
+exports.normalizeMode = normalizeMode;
+exports.defineManifest = defineManifest;
+/**
+ * Normalize mode config from shorthand or full config
+ */
+function normalizeMode(mode) {
+    if (!mode || mode === 'full') {
+        return { type: 'full' };
+    }
+    if (mode === 'headless') {
+        return { type: 'headless', include: ['validation', 'hooks', 'services', 'i18n'] };
+    }
+    if (mode === 'api-only') {
+        return { type: 'api-only', include: ['validation', 'services'] };
+    }
+    return mode;
+}
+// Compile manifest definition to IR
+function compileManifest(definition) {
+    const mode = normalizeMode(definition.mode);
+    // Validate: full mode requires database
+    if (mode.type === 'full' && !definition.database) {
+        throw new Error(`Mode 'full' requires database configuration.\n` +
+            `Fix: Add database config or use mode: 'headless' for frontend-only projects.`);
+    }
+    return {
+        template: definition.template,
+        mode,
+        entities: definition.entities,
+        source: definition.source,
+        database: definition.database,
+        auth: {
+            enabled: false,
+            adapter: 'drizzle',
+            providers: [],
+            sessionStrategy: 'jwt',
+            ...definition.auth,
+        },
+        i18n: {
+            languages: ['en'],
+            defaultLanguage: 'en',
+            outputDir: './messages',
+            ...definition.i18n,
+        },
+        observability: {
+            logging: { enabled: false, level: 'info', format: 'json' },
+            telemetry: { enabled: false, events: [] },
+            audit: { enabled: false },
+            ...definition.observability,
+        },
+        tenancy: {
+            enabled: false,
+            field: 'organizationId',
+            ...definition.tenancy,
+        },
+        defaults: {
+            timestamps: true,
+            softDelete: false,
+            audit: false,
+            ...definition.defaults,
+        },
+    };
+}
+/**
+ * Define a manifest with entities and configuration
+ *
+ * @param definition - Manifest configuration
+ * @returns Compiled ManifestIR for use by CLI and generators
+ *
+ * @example
+ * ```typescript
+ * const manifest = defineManifest({
+ *   template: 'nextjs-drizzle-trpc',
+ *   entities: [User, Post],
+ *   database: { type: 'sqlite', file: './sqlite.db' },
+ * })
+ * ```
+ */
+function defineManifest(definition) {
+    return compileManifest(definition);
+}
+/**
+ * Alias for defineManifest - use in archetype.config.ts
+ *
+ * @example
+ * ```typescript
+ * // archetype.config.ts
+ * import { defineConfig } from 'archetype-engine'
+ *
+ * export default defineConfig({
+ *   template: 'nextjs-drizzle-trpc',
+ *   entities: [User, Post],
+ *   database: { type: 'postgres', url: process.env.DATABASE_URL },
+ * })
+ * ```
+ */
+exports.defineConfig = defineManifest;

package/dist/src/relations.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Relation builders for entity definitions
+ * @module relations
+ */
+import type { FieldBuilder, FieldConfig } from './fields';
+export type RelationType = 'hasOne' | 'hasMany' | 'belongsToMany';
+/**
+ * Pivot table configuration for belongsToMany relations
+ */
+export interface PivotConfig {
+    /** Custom name for the junction/pivot table */
+    table?: string;
+    /** Additional fields on the pivot table */
+    fields?: Record<string, FieldConfig>;
+}
+export interface RelationConfig {
+    type: RelationType;
+    entity: string;
+    /** Optional custom foreign key field name */
+    field?: string;
+    /** Whether the relation is optional (for hasOne relations) */
+    optional?: boolean;
+    /** Pivot table configuration for belongsToMany */
+    pivot?: PivotConfig;
+}
+export interface RelationBuilder {
+    readonly _config: RelationConfig;
+    /** Override the default foreign key field name */
+    field(name: string): RelationBuilder;
+    /** Mark this relation as optional (foreign key can be null) */
+    optional(): RelationBuilder;
+}
+export interface BelongsToManyBuilder extends RelationBuilder {
+    /** Configure pivot table with additional fields */
+    through(options: {
+        table?: string;
+        fields: Record<string, FieldBuilder>;
+    }): BelongsToManyBuilder;
+}
+/**
+ * Create a one-to-one relation (adds foreign key to this entity)
+ *
+ * @param entity - Target entity name
+ * @returns RelationBuilder
+ *
+ * @example
+ * ```typescript
+ * relations: {
+ *   author: hasOne('User'),
+ *   category: hasOne('Category').field('categoryId'),
+ * }
+ * ```
+ */
+export declare function hasOne(entity: string): RelationBuilder;
+/**
+ * Create a one-to-many relation (target entity has FK to this entity)
+ *
+ * @param entity - Target entity name
+ * @returns RelationBuilder
+ *
+ * @example
+ * ```typescript
+ * relations: {
+ *   posts: hasMany('Post'),
+ *   comments: hasMany('Comment'),
+ * }
+ * ```
+ */
+export declare function hasMany(entity: string): RelationBuilder;
+/**
+ * Create a many-to-many relation (creates junction table)
+ *
+ * @param entity - Target entity name
+ * @returns BelongsToManyBuilder
+ *
+ * @example
+ * ```typescript
+ * // Simple many-to-many
+ * relations: {
+ *   tags: belongsToMany('Tag'),
+ * }
+ *
+ * // With pivot data (e.g., OrderItem with quantity)
+ * relations: {
+ *   products: belongsToMany('Product').through({
+ *     table: 'order_items',
+ *     fields: {
+ *       quantity: number().required().min(1),
+ *       unitPrice: number().required(),
+ *     }
+ *   }),
+ * }
+ * ```
+ */
+export declare function belongsToMany(entity: string): BelongsToManyBuilder;
+//# sourceMappingURL=relations.d.ts.map

package/dist/src/relations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relations.d.ts","sourceRoot":"","sources":["../../src/relations.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAEzD,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,SAAS,GAAG,eAAe,CAAA;AAEjE;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,+CAA+C;IAC/C,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,2CAA2C;IAC3C,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;CACrC;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,YAAY,CAAA;IAClB,MAAM,EAAE,MAAM,CAAA;IACd,6CAA6C;IAC7C,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,kDAAkD;IAClD,KAAK,CAAC,EAAE,WAAW,CAAA;CACpB;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAA;IAChC,kDAAkD;IAClD,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,CAAA;IACpC,+DAA+D;IAC/D,QAAQ,IAAI,eAAe,CAAA;CAC5B;AAED,MAAM,WAAW,oBAAqB,SAAQ,eAAe;IAC3D,mDAAmD;IACnD,OAAO,CAAC,OAAO,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAA;KAAE,GAAG,oBAAoB,CAAA;CACjG;AAgCD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,CAKtD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,CAKvD;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,oBAAoB,CAKlE"}

package/dist/src/relations.js

@@ -0,0 +1,108 @@
+"use strict";
+/**
+ * Relation builders for entity definitions
+ * @module relations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasOne = hasOne;
+exports.hasMany = hasMany;
+exports.belongsToMany = belongsToMany;
+function createRelationBuilder(config) {
+    return {
+        _config: config,
+        field: (name) => createRelationBuilder({ ...config, field: name }),
+        optional: () => createRelationBuilder({ ...config, optional: true }),
+    };
+}
+function createBelongsToManyBuilder(config) {
+    return {
+        _config: config,
+        field: (name) => createBelongsToManyBuilder({ ...config, field: name }),
+        optional: () => createBelongsToManyBuilder({ ...config, optional: true }),
+        through: (options) => {
+            // Extract field configs from builders
+            const fieldConfigs = {};
+            for (const [fieldName, builder] of Object.entries(options.fields)) {
+                fieldConfigs[fieldName] = builder._config;
+            }
+            return createBelongsToManyBuilder({
+                ...config,
+                pivot: {
+                    table: options.table,
+                    fields: fieldConfigs,
+                },
+            });
+        },
+    };
+}
+/**
+ * Create a one-to-one relation (adds foreign key to this entity)
+ *
+ * @param entity - Target entity name
+ * @returns RelationBuilder
+ *
+ * @example
+ * ```typescript
+ * relations: {
+ *   author: hasOne('User'),
+ *   category: hasOne('Category').field('categoryId'),
+ * }
+ * ```
+ */
+function hasOne(entity) {
+    return createRelationBuilder({
+        type: 'hasOne',
+        entity,
+    });
+}
+/**
+ * Create a one-to-many relation (target entity has FK to this entity)
+ *
+ * @param entity - Target entity name
+ * @returns RelationBuilder
+ *
+ * @example
+ * ```typescript
+ * relations: {
+ *   posts: hasMany('Post'),
+ *   comments: hasMany('Comment'),
+ * }
+ * ```
+ */
+function hasMany(entity) {
+    return createRelationBuilder({
+        type: 'hasMany',
+        entity,
+    });
+}
+/**
+ * Create a many-to-many relation (creates junction table)
+ *
+ * @param entity - Target entity name
+ * @returns BelongsToManyBuilder
+ *
+ * @example
+ * ```typescript
+ * // Simple many-to-many
+ * relations: {
+ *   tags: belongsToMany('Tag'),
+ * }
+ *
+ * // With pivot data (e.g., OrderItem with quantity)
+ * relations: {
+ *   products: belongsToMany('Product').through({
+ *     table: 'order_items',
+ *     fields: {
+ *       quantity: number().required().min(1),
+ *       unitPrice: number().required(),
+ *     }
+ *   }),
+ * }
+ * ```
+ */
+function belongsToMany(entity) {
+    return createBelongsToManyBuilder({
+        type: 'belongsToMany',
+        entity,
+    });
+}

package/dist/src/source.d.ts

@@ -0,0 +1,93 @@
+/**
+ * External API source configuration
+ * @module source
+ */
+/**
+ * Options for external API source configuration
+ */
+export interface ExternalSourceOptions {
+    /** Path prefix like '/v1' or '/api' - prepended to all endpoints */
+    pathPrefix?: string;
+    /** Override auto-pluralization: 'product' instead of 'products' */
+    resourceName?: string;
+    /** Override specific endpoints when API doesn't follow REST conventions */
+    override?: {
+        list?: string;
+        get?: string;
+        create?: string;
+        update?: string;
+        delete?: string;
+    };
+    /** Auth config for this API */
+    auth?: {
+        type: 'bearer' | 'api-key';
+        header?: string;
+    };
+}
+/**
+ * Compiled external source configuration
+ */
+export interface ExternalSourceConfig {
+    type: 'external';
+    /** Base URL - can use 'env:VARIABLE_NAME' syntax */
+    baseUrl: string;
+    /** Path prefix */
+    pathPrefix: string;
+    /** Resource name (pluralized entity name) */
+    resourceName?: string;
+    /** Resolved endpoints */
+    endpoints: {
+        list: string;
+        get: string;
+        create: string;
+        update: string;
+        delete: string;
+    };
+    /** Auth configuration */
+    auth?: {
+        type: 'bearer' | 'api-key';
+        header: string;
+    };
+}
+/**
+ * Database source configuration (default when no external source)
+ */
+export interface DatabaseSourceConfig {
+    type: 'database';
+}
+/**
+ * Entity source configuration - either database or external API
+ */
+export type SourceConfig = DatabaseSourceConfig | ExternalSourceConfig;
+/**
+ * Create an external API source configuration
+ *
+ * @param baseUrl - Base URL for the API. Supports 'env:VARIABLE_NAME' syntax.
+ * @param options - Optional configuration for path prefix, resource name, endpoint overrides
+ * @returns ExternalSourceConfig for use in entity or manifest source field
+ *
+ * @example
+ * ```typescript
+ * // Simple - all defaults
+ * source: external('env:API_URL')
+ * // Generates: GET/POST /products, GET/PUT/DELETE /products/:id
+ *
+ * // With version prefix
+ * source: external('env:API_URL', { pathPrefix: '/v1' })
+ * // Generates: /v1/products, /v1/products/:id
+ *
+ * // Override weird endpoints
+ * source: external('env:LEGACY_API', {
+ *   override: {
+ *     list: 'GET /catalog/search',
+ *     get: 'GET /catalog/item/:sku',
+ *   }
+ * })
+ * ```
+ */
+export declare function external(baseUrl: string, options?: ExternalSourceOptions): ExternalSourceConfig;
+/**
+ * Resolve the final endpoints for an entity, using its name for pluralization
+ */
+export declare function resolveEndpoints(entityName: string, source: ExternalSourceConfig): ExternalSourceConfig['endpoints'];
+//# sourceMappingURL=source.d.ts.map

package/dist/src/source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source.d.ts","sourceRoot":"","sources":["../../src/source.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,oEAAoE;IACpE,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,mEAAmE;IACnE,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,2EAA2E;IAC3E,QAAQ,CAAC,EAAE;QACT,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,GAAG,CAAC,EAAE,MAAM,CAAA;QACZ,MAAM,CAAC,EAAE,MAAM,CAAA;QACf,MAAM,CAAC,EAAE,MAAM,CAAA;QACf,MAAM,CAAC,EAAE,MAAM,CAAA;KAChB,CAAA;IACD,+BAA+B;IAC/B,IAAI,CAAC,EAAE;QACL,IAAI,EAAE,QAAQ,GAAG,SAAS,CAAA;QAC1B,MAAM,CAAC,EAAE,MAAM,CAAA;KAChB,CAAA;CACF;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,UAAU,CAAA;IAChB,oDAAoD;IACpD,OAAO,EAAE,MAAM,CAAA;IACf,kBAAkB;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB,6CAA6C;IAC7C,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,yBAAyB;IACzB,SAAS,EAAE;QACT,IAAI,EAAE,MAAM,CAAA;QACZ,GAAG,EAAE,MAAM,CAAA;QACX,MAAM,EAAE,MAAM,CAAA;QACd,MAAM,EAAE,MAAM,CAAA;QACd,MAAM,EAAE,MAAM,CAAA;KACf,CAAA;IACD,yBAAyB;IACzB,IAAI,CAAC,EAAE;QACL,IAAI,EAAE,QAAQ,GAAG,SAAS,CAAA;QAC1B,MAAM,EAAE,MAAM,CAAA;KACf,CAAA;CACF;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,UAAU,CAAA;CACjB;AAED;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,oBAAoB,GAAG,oBAAoB,CAAA;AAqBtE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,QAAQ,CACtB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,qBAA0B,GAClC,oBAAoB,CA0BtB;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,oBAAoB,GAC3B,oBAAoB,CAAC,WAAW,CAAC,CAWnC"}

package/dist/src/source.js

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * External API source configuration
+ * @module source
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.external = external;
+exports.resolveEndpoints = resolveEndpoints;
+const utils_1 = require("./core/utils");
+/**
+ * Generate REST endpoints from entity name and options
+ */
+function generateEndpoints(entityName, options = {}) {
+    const resource = options.resourceName || (0, utils_1.pluralize)(entityName.toLowerCase());
+    const prefix = options.pathPrefix || '';
+    return {
+        list: options.override?.list || `GET ${prefix}/${resource}`,
+        get: options.override?.get || `GET ${prefix}/${resource}/:id`,
+        create: options.override?.create || `POST ${prefix}/${resource}`,
+        update: options.override?.update || `PUT ${prefix}/${resource}/:id`,
+        delete: options.override?.delete || `DELETE ${prefix}/${resource}/:id`,
+    };
+}
+/**
+ * Create an external API source configuration
+ *
+ * @param baseUrl - Base URL for the API. Supports 'env:VARIABLE_NAME' syntax.
+ * @param options - Optional configuration for path prefix, resource name, endpoint overrides
+ * @returns ExternalSourceConfig for use in entity or manifest source field
+ *
+ * @example
+ * ```typescript
+ * // Simple - all defaults
+ * source: external('env:API_URL')
+ * // Generates: GET/POST /products, GET/PUT/DELETE /products/:id
+ *
+ * // With version prefix
+ * source: external('env:API_URL', { pathPrefix: '/v1' })
+ * // Generates: /v1/products, /v1/products/:id
+ *
+ * // Override weird endpoints
+ * source: external('env:LEGACY_API', {
+ *   override: {
+ *     list: 'GET /catalog/search',
+ *     get: 'GET /catalog/item/:sku',
+ *   }
+ * })
+ * ```
+ */
+function external(baseUrl, options = {}) {
+    // Generate default auth header based on type
+    let auth;
+    if (options.auth) {
+        auth = {
+            type: options.auth.type,
+            header: options.auth.header || (options.auth.type === 'api-key' ? 'X-API-Key' : 'Authorization'),
+        };
+    }
+    return {
+        type: 'external',
+        baseUrl,
+        pathPrefix: options.pathPrefix || '',
+        resourceName: options.resourceName,
+        // Endpoints will be generated per-entity when compiled
+        // Using placeholder - actual generation happens in resolveEntitySource
+        endpoints: {
+            list: options.override?.list || '',
+            get: options.override?.get || '',
+            create: options.override?.create || '',
+            update: options.override?.update || '',
+            delete: options.override?.delete || '',
+        },
+        auth,
+    };
+}
+/**
+ * Resolve the final endpoints for an entity, using its name for pluralization
+ */
+function resolveEndpoints(entityName, source) {
+    const resource = source.resourceName || (0, utils_1.pluralize)(entityName.toLowerCase());
+    const prefix = source.pathPrefix;
+    return {
+        list: source.endpoints.list || `GET ${prefix}/${resource}`,
+        get: source.endpoints.get || `GET ${prefix}/${resource}/:id`,
+        create: source.endpoints.create || `POST ${prefix}/${resource}`,
+        update: source.endpoints.update || `PUT ${prefix}/${resource}/:id`,
+        delete: source.endpoints.delete || `DELETE ${prefix}/${resource}/:id`,
+    };
+}

package/dist/src/template/context.d.ts

@@ -0,0 +1,34 @@
+import type { ManifestIR } from '../manifest';
+import type { TemplateConfig } from './types';
+import { toSnakeCase, pluralize, toCamelCase, toPascalCase, getTableName, getColumnName } from '../core/utils';
+/**
+ * Context passed to generators with common utilities
+ */
+export interface GeneratorContext {
+    /** Template configuration */
+    config: TemplateConfig;
+    /** Naming utilities */
+    naming: {
+        toSnakeCase: typeof toSnakeCase;
+        pluralize: typeof pluralize;
+        toCamelCase: typeof toCamelCase;
+        toPascalCase: typeof toPascalCase;
+        getTableName: typeof getTableName;
+        getColumnName: typeof getColumnName;
+    };
+    /** Database info from manifest (undefined in headless mode) */
+    database: {
+        type: 'sqlite' | 'postgres' | 'mysql' | undefined;
+        isSqlite: boolean;
+        isPostgres: boolean;
+        isMysql: boolean;
+        isHeadless: boolean;
+    };
+    /** Resolve import path using aliases */
+    resolvePath: (alias: string) => string;
+}
+/**
+ * Create a generator context from manifest and config
+ */
+export declare function createContext(manifest: ManifestIR, config: TemplateConfig): GeneratorContext;
+//# sourceMappingURL=context.d.ts.map