cloesce 0.0.3

package/dist/cloesce.d.ts.map

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

package/dist/cloesce.js

@@ -0,0 +1,453 @@
+import { left, right, isNullableType, getNavigationPropertyCidlType, } from "./common.js";
+/**
+ * Singleton instances of the MetaCidl and Constructor Registry.
+ * These values are guaranteed to never change throughout a workers lifetime.
+ */
+class MetaContainer {
+    ast;
+    constructorRegistry;
+    static instance;
+    constructor(ast, constructorRegistry) {
+        this.ast = ast;
+        this.constructorRegistry = constructorRegistry;
+    }
+    static init(ast, constructorRegistry) {
+        if (!this.instance) {
+            this.instance = new MetaContainer(ast, constructorRegistry);
+        }
+    }
+    static get() {
+        return this.instance;
+    }
+}
+/**
+ * Creates model instances given a properly formatted SQL record
+ * (either a foreign-key-less model or derived from a Cloesce generated view)
+ * @param ctor The type of the model
+ * @param records SQL records
+ * @param includeTree The include tree to use when parsing the records
+ * @returns
+ */
+export function modelsFromSql(ctor, records, includeTree) {
+    const { ast, constructorRegistry } = MetaContainer.get();
+    return _modelsFromSql(ctor.name, ast, constructorRegistry, records, includeTree);
+}
+/**
+ * Cloesce entry point. Given a request, undergoes routing, validating,
+ * hydrating, and method dispatch.
+ * @param ast The CIDL AST
+ * @param constructorRegistry A mapping of user defined class names to their respective constructor
+ * @param instanceRegistry A mapping of a dependency class name to its instantiated object.
+ * @param request An incoming request to the workers server
+ * @param api_route The url's path to the api, e.g. api/v1/fooapi/
+ * @param envMeta Meta information on the wrangler env and D1 databases
+ * @returns A Response with an `HttpResult` JSON body.
+ */
+export async function cloesce(request, ast, constructorRegistry, instanceRegistry, envMeta, api_route) {
+    MetaContainer.init(ast, constructorRegistry);
+    const d1 = instanceRegistry.get(envMeta.envName)[envMeta.dbName];
+    // Match the route to a model method
+    const route = matchRoute(request, ast, api_route);
+    if (!route.ok) {
+        return toResponse(route.value);
+    }
+    const { method, model, id } = route.value;
+    // Validate request body to the model method
+    const isValidRequest = await validateRequest(request, ast, model, method, id);
+    if (!isValidRequest.ok) {
+        return toResponse(isValidRequest.value);
+    }
+    const [requestParamMap, dataSource] = isValidRequest.value;
+    // Instantatiate the model
+    let instance;
+    if (method.is_static) {
+        instance = constructorRegistry[model.name];
+    }
+    else {
+        const successfulModel = await hydrateModel(ast, constructorRegistry, d1, model, id, dataSource);
+        if (!successfulModel.ok) {
+            return toResponse(successfulModel.value);
+        }
+        instance = successfulModel.value;
+    }
+    // Dispatch a method on the model and return the result
+    return toResponse(await methodDispatch(instance, instanceRegistry, envMeta, method, requestParamMap));
+}
+/**
+ * Matches a request to a method on a model.
+ * @param api_route The route from the domain to the actual API, ie https://foo.com/route/to/api => route/to/api/
+ * @returns 404 or a `MatchedRoute`
+ */
+function matchRoute(request, ast, api_route) {
+    const url = new URL(request.url);
+    const notFound = (e) => left(errorState(404, `Path not found: ${e} ${url.pathname}`));
+    const routeParts = url.pathname
+        .slice(api_route.length)
+        .split("/")
+        .filter(Boolean);
+    if (routeParts.length < 2) {
+        return notFound("Expected /model/method or /model/:id/method");
+    }
+    // Attempt to extract from routeParts
+    const modelName = routeParts[0];
+    const methodName = routeParts[routeParts.length - 1];
+    const id = routeParts.length === 3 ? routeParts[1] : null;
+    const model = ast.models[modelName];
+    if (!model) {
+        return notFound(`Unknown model ${modelName}`);
+    }
+    const method = model.methods[methodName];
+    if (!method) {
+        return notFound(`Unknown method ${modelName}.${methodName}`);
+    }
+    if (request.method !== method.http_verb) {
+        return notFound("Unmatched HTTP method");
+    }
+    return right({
+        model,
+        method,
+        id,
+    });
+}
+/**
+ * Validates the request's body/search params against a ModelMethod
+ * @returns 400 or a `RequestParamMap` consisting of each parameters name mapped to its value, and
+ * a data source
+ */
+async function validateRequest(request, ast, model, method, id) {
+    // Error state: any missing parameter, body, or malformed input will exit with 400.
+    const invalidRequest = (e) => left(errorState(400, `Invalid Request Body: ${e}`));
+    if (!method.is_static && id == null) {
+        return invalidRequest("Id's are required for instantiated methods.");
+    }
+    // Filter out any injected parameters that will not be passed
+    // by the query.
+    const requiredParams = method.parameters.filter((p) => !(typeof p.cidl_type === "object" &&
+        p.cidl_type !== null &&
+        "Inject" in p.cidl_type));
+    // Extract data source
+    const url = new URL(request.url);
+    let dataSource = url.searchParams.get("dataSource");
+    // Extract url or body parameters
+    let requestBodyMap;
+    if (method.http_verb === "GET") {
+        requestBodyMap = Object.fromEntries(url.searchParams.entries());
+    }
+    else {
+        try {
+            requestBodyMap = await request.json();
+        }
+        catch {
+            return invalidRequest("Could not retrieve JSON body.");
+        }
+    }
+    // Validate data source if exists
+    if (dataSource && !(dataSource in model.data_sources)) {
+        return invalidRequest(`Unknown data source ${dataSource}`);
+    }
+    // Ensure all required params exist
+    if (!requiredParams.every((p) => p.name in requestBodyMap)) {
+        return invalidRequest(`Missing parameters.`);
+    }
+    // Validate all parameters type
+    for (const p of requiredParams) {
+        const value = requestBodyMap[p.name];
+        if (!validateCidlType(ast, value, p.cidl_type)) {
+            return invalidRequest("Invalid parameters.");
+        }
+    }
+    return right([requestBodyMap, dataSource]);
+}
+/**
+ * Queries D1 for a particular model's ID, then transforms the SQL column output into
+ * an instance of a model using the provided include tree and metadata as a guide.
+ * @returns 404 if no record was found for the provided ID
+ * @returns 500 if the D1 database is not synced with Cloesce and yields an error
+ * @returns The instantiated model on success
+ */
+async function hydrateModel(ast, constructorRegistry, d1, model, id, dataSource) {
+    // Error state: If the D1 database has been tweaked outside of Cloesce
+    // resulting in a malformed query, exit with a 500.
+    const malformedQuery = (e) => left(errorState(500, `Error in hydration query, is the database out of sync with the backend?: ${e instanceof Error ? e.message : String(e)}`));
+    // Error state: If no record is found for the id, return a 404
+    const missingRecord = left(errorState(404, "Record not found"));
+    const pk = model.primary_key.name;
+    const query = dataSource !== null
+        ? `SELECT * FROM "${model.name}.${dataSource}" WHERE "${model.name}.${pk}" = ?`
+        : `SELECT * FROM "${model.name}" WHERE "${pk}" = ?`;
+    // Query DB
+    let records;
+    try {
+        records = await d1.prepare(query).bind(id).run();
+        if (!records) {
+            return missingRecord;
+        }
+        if (records.error) {
+            return malformedQuery(records.error);
+        }
+    }
+    catch (e) {
+        return malformedQuery(e);
+    }
+    // Get include tree
+    const includeTree = dataSource !== null ? model.data_sources[dataSource].tree : {};
+    // Hydrate
+    const models = _modelsFromSql(model.name, ast, constructorRegistry, records.results, includeTree);
+    console.log(JSON.stringify(models));
+    return right(models[0]);
+}
+/**
+ * Calls a method on a model given a list of parameters.
+ * @returns 500 on an uncaught client error, 200 with a result body on success
+ */
+async function methodDispatch(instance, instanceRegistry, envMeta, method, params) {
+    // Error state: Client code ran into an uncaught exception.
+    const uncaughtException = (e) => errorState(500, `Uncaught exception in method dispatch: ${e instanceof Error ? e.message : String(e)}`);
+    // For now, the only injected dependency is the wrangler env,
+    // so we will assume that is what this is
+    const paramArray = method.parameters.map((p) => params[p.name] == undefined
+        ? instanceRegistry.get(envMeta.envName)
+        : params[p.name]);
+    // Ensure the result is always some HttpResult
+    const resultWrapper = (res) => {
+        const rt = method.return_type;
+        if (rt === null) {
+            return { ok: true, status: 200 };
+        }
+        if (typeof rt === "object" && rt !== null && "HttpResult" in rt) {
+            return res;
+        }
+        return { ok: true, status: 200, data: res };
+    };
+    try {
+        return resultWrapper(await instance[method.name](...paramArray));
+    }
+    catch (e) {
+        return uncaughtException(e);
+    }
+}
+function validateCidlType(ast, value, cidlType) {
+    if (value === undefined)
+        return false;
+    // TODO: consequences of null checking like this? 'null' is passed in
+    // as a string for GET requests...
+    const nullable = isNullableType(cidlType);
+    if (value == null || value === "null")
+        return nullable;
+    if (nullable) {
+        cidlType = cidlType.Nullable; // Unwrap the nullable type
+    }
+    // Handle primitive string types with switch
+    if (typeof cidlType === "string") {
+        switch (cidlType) {
+            case "Integer":
+                return Number.isInteger(Number(value));
+            case "Real":
+                return !Number.isNaN(Number(value));
+            case "Text":
+                return typeof value === "string";
+            case "Blob":
+                return value instanceof Blob || value instanceof ArrayBuffer;
+            default:
+                return false;
+        }
+    }
+    // Handle Models
+    if ("Object" in cidlType && ast.models[cidlType.Object]) {
+        const model = ast.models[cidlType.Object];
+        if (!model || typeof value !== "object")
+            return false;
+        const valueObj = value;
+        // Validate attributes
+        if (!model.attributes.every((attr) => validateCidlType(ast, valueObj[attr.value.name], attr.value.cidl_type))) {
+            return false;
+        }
+        // Validate navigation properties
+        return model.navigation_properties.every((nav) => {
+            const navValue = valueObj[nav.var_name];
+            return (navValue == null ||
+                validateCidlType(ast, navValue, getNavigationPropertyCidlType(nav)));
+        });
+    }
+    // Handle Plain Old Objects
+    if ("Object" in cidlType && ast.poos[cidlType.Object]) {
+        const poo = ast.poos[cidlType.Object];
+        if (!poo || typeof value !== "object")
+            return false;
+        const valueObj = value;
+        // Validate attributes
+        if (!poo.attributes.every((attr) => validateCidlType(ast, valueObj[attr.name], attr.cidl_type))) {
+            return false;
+        }
+    }
+    if ("Array" in cidlType) {
+        const arr = cidlType.Array;
+        return (Array.isArray(value) && value.every((v) => validateCidlType(ast, v, arr)));
+    }
+    if ("HttpResult" in cidlType) {
+        if (value === null)
+            return cidlType.HttpResult === null;
+        if (cidlType.HttpResult === null)
+            return false;
+        return validateCidlType(ast, value, cidlType.HttpResult);
+    }
+    return false;
+}
+/**
+ * Actual implementation of sql to model mapping.
+ *
+ * TODO: If we don't want to write this in every language, would it be possible to create a
+ * single WASM binary for this method?
+ *
+ * @throws generic errors if the metadata is missing some value
+ */
+// Main function that creates instances from SQL records
+function _modelsFromSql(modelName, ast, constructorRegistry, records, includeTree) {
+    const model = ast.models[modelName];
+    if (!model)
+        return [];
+    const Constructor = constructorRegistry[modelName];
+    if (!Constructor)
+        return [];
+    const pkName = model.primary_key.name;
+    const resultMap = new Map();
+    for (const record of records) {
+        const pkValue = record[`${modelName}.${pkName}`] ?? record[pkName];
+        if (pkValue == null)
+            continue;
+        let instance = resultMap.get(pkValue);
+        if (!instance) {
+            instance = new Constructor();
+            instance[pkName] = pkValue;
+            // Set scalar attributes
+            for (const attr of model.attributes) {
+                const attrName = attr.value.name;
+                const prefixedKey = `${modelName}.${attrName}`;
+                const nonPrefixedKey = attrName;
+                if (prefixedKey in record) {
+                    instance[attrName] = record[prefixedKey];
+                }
+                else if (nonPrefixedKey in record) {
+                    instance[attrName] = record[nonPrefixedKey];
+                }
+            }
+            // Initialize ALL navigation properties at root level
+            // If not in include tree, initialize OneToMany and ManyToMany as empty arrays
+            for (const navProp of model.navigation_properties) {
+                if ("OneToMany" in navProp.kind || "ManyToMany" in navProp.kind) {
+                    // Always initialize OneToMany and ManyToMany as empty arrays
+                    instance[navProp.var_name] = [];
+                }
+                // OneToOne properties left as undefined unless populated
+            }
+            resultMap.set(pkValue, instance);
+        }
+        // Process navigation properties that are in the include tree
+        if (includeTree) {
+            processNavigationProperties(instance, model, modelName, includeTree, record, ast, constructorRegistry);
+        }
+    }
+    return Array.from(resultMap.values());
+}
+function processNavigationProperties(instance, model, prefix, includeTree, record, ast, constructorRegistry) {
+    for (const navProp of model.navigation_properties) {
+        if (!(navProp.var_name in includeTree)) {
+            continue;
+        }
+        const nestedModel = ast.models[navProp.model_name];
+        if (!nestedModel) {
+            continue;
+        }
+        // Extract nested model's primary key - check both prefixed and non-prefixed
+        const nestedPkName = nestedModel.primary_key.name;
+        const prefixedNestedPkKey = `${prefix}.${navProp.var_name}.${nestedPkName}`;
+        const nonPrefixedNestedPkKey = `${navProp.var_name}.${nestedPkName}`;
+        const nestedPkValue = record[prefixedNestedPkKey] ?? record[nonPrefixedNestedPkKey];
+        if (nestedPkValue == null) {
+            continue; // No nested object in this row
+        }
+        // Determine if this is OneToMany/ManyToMany or OneToOne
+        const isOneToMany = "OneToMany" in navProp.kind || "ManyToMany" in navProp.kind;
+        // Check if we already added this nested object (for OneToMany)
+        if (isOneToMany) {
+            const navArray = instance[navProp.var_name];
+            const alreadyExists = navArray.some((item) => item[nestedPkName] === nestedPkValue);
+            if (alreadyExists) {
+                continue;
+            }
+        }
+        else {
+            // For OneToOne, check if already set
+            if (instance[navProp.var_name] != null) {
+                continue;
+            }
+        }
+        const NestedConstructor = constructorRegistry[navProp.model_name];
+        if (!NestedConstructor) {
+            continue;
+        }
+        const nestedInstance = new NestedConstructor();
+        nestedInstance[nestedPkName] = nestedPkValue;
+        // Assign nested scalar attributes - check both prefixed and non-prefixed
+        for (const nestedAttr of nestedModel.attributes) {
+            const nestedAttrName = nestedAttr.value.name;
+            const prefixedKey = `${prefix}.${navProp.var_name}.${nestedAttrName}`;
+            const nonPrefixedKey = `${navProp.var_name}.${nestedAttrName}`;
+            // Check prefixed key first, then non-prefixed
+            if (prefixedKey in record) {
+                nestedInstance[nestedAttrName] = record[prefixedKey];
+            }
+            else if (nonPrefixedKey in record) {
+                nestedInstance[nestedAttrName] = record[nonPrefixedKey];
+            }
+        }
+        // Initialize ALL navigation properties on the nested instance
+        // If not in include tree, initialize OneToMany and ManyToMany as empty arrays
+        const nestedIncludeTree = includeTree[navProp.var_name];
+        for (const nestedNavProp of nestedModel.navigation_properties) {
+            const isInIncludeTree = nestedIncludeTree &&
+                typeof nestedIncludeTree === "object" &&
+                nestedNavProp.var_name in nestedIncludeTree;
+            if ("OneToMany" in nestedNavProp.kind ||
+                "ManyToMany" in nestedNavProp.kind) {
+                // Always initialize OneToMany and ManyToMany as arrays (empty if not in include tree)
+                nestedInstance[nestedNavProp.var_name] = [];
+            }
+            else if (!isInIncludeTree) {
+                // OneToOne not in include tree - leave as undefined or null
+                // Will be set during recursive processing if in include tree
+            }
+        }
+        // Recursively process nested navigation properties that are in the include tree
+        if (nestedIncludeTree && typeof nestedIncludeTree === "object") {
+            processNavigationProperties(nestedInstance, nestedModel, `${prefix}.${navProp.var_name}`, nestedIncludeTree, record, ast, constructorRegistry);
+        }
+        // Assign the nested instance based on relationship type
+        if (isOneToMany) {
+            instance[navProp.var_name].push(nestedInstance);
+        }
+        else {
+            // OneToOne - assign directly
+            instance[navProp.var_name] = nestedInstance;
+        }
+    }
+}
+function errorState(status, message) {
+    return { ok: false, status, message };
+}
+function toResponse(r) {
+    return new Response(JSON.stringify(r), {
+        status: r.status,
+        headers: { "Content-Type": "application/json" },
+    });
+}
+/**
+ * Each individual state of the `cloesce` function for testing purposes.
+ */
+export const _cloesceInternal = {
+    matchRoute,
+    validateRequest,
+    hydrateModel,
+    methodDispatch,
+    _modelsFromSql,
+};

package/dist/common.d.ts

@@ -0,0 +1,96 @@
+export type Either<L, R> = {
+    ok: false;
+    value: L;
+} | {
+    ok: true;
+    value: R;
+};
+export declare function left<L>(value: L): Either<L, never>;
+export declare function right<R>(value: R): Either<never, R>;
+export type HttpResult<T = unknown> = {
+    ok: boolean;
+    status: number;
+    data?: T;
+    message?: string;
+};
+export type CidlType = "Void" | "Integer" | "Real" | "Text" | "Blob" | {
+    Inject: string;
+} | {
+    Model: string;
+} | {
+    Nullable: CidlType;
+} | {
+    Array: CidlType;
+} | {
+    HttpResult: CidlType;
+};
+export declare function isNullableType(ty: CidlType): boolean;
+export declare enum HttpVerb {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    PATCH = "PATCH",
+    DELETE = "DELETE"
+}
+export interface NamedTypedValue {
+    name: string;
+    cidl_type: CidlType;
+}
+export interface ModelAttribute {
+    value: NamedTypedValue;
+    foreign_key_reference: string | null;
+}
+export interface ModelMethod {
+    name: string;
+    is_static: boolean;
+    http_verb: HttpVerb;
+    return_type: CidlType | null;
+    parameters: NamedTypedValue[];
+}
+export type NavigationPropertyKind = {
+    OneToOne: {
+        reference: string;
+    };
+} | {
+    OneToMany: {
+        reference: string;
+    };
+} | {
+    ManyToMany: {
+        unique_id: string;
+    };
+};
+export interface NavigationProperty {
+    var_name: string;
+    model_name: string;
+    kind: NavigationPropertyKind;
+}
+export declare function getNavigationPropertyCidlType(nav: NavigationProperty): CidlType;
+export interface Model {
+    name: string;
+    primary_key: NamedTypedValue;
+    attributes: ModelAttribute[];
+    navigation_properties: NavigationProperty[];
+    methods: Record<string, ModelMethod>;
+    data_sources: Record<string, DataSource>;
+    source_path: string;
+}
+export interface CidlIncludeTree {
+    [key: string]: CidlIncludeTree;
+}
+export interface DataSource {
+    name: string;
+    tree: CidlIncludeTree;
+}
+export interface WranglerEnv {
+    name: string;
+    source_path: string;
+}
+export interface CloesceAst {
+    version: string;
+    project_name: string;
+    language: "TypeScript";
+    wrangler_env: WranglerEnv;
+    models: Record<string, Model>;
+}
+//# sourceMappingURL=common.d.ts.map

package/dist/common.d.ts.map

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

package/dist/common.js

@@ -0,0 +1,96 @@
+export function left(value) {
+    return { ok: false, value };
+}
+export function right(value) {
+    return { ok: true, value };
+}
+export var ExtractorErrorCode;
+(function (ExtractorErrorCode) {
+    ExtractorErrorCode[ExtractorErrorCode["UnknownType"] = 0] = "UnknownType";
+    ExtractorErrorCode[ExtractorErrorCode["MultipleGenericType"] = 1] = "MultipleGenericType";
+    ExtractorErrorCode[ExtractorErrorCode["InvalidIncludeTree"] = 2] = "InvalidIncludeTree";
+    ExtractorErrorCode[ExtractorErrorCode["UnknownNavigationPropertyReference"] = 3] = "UnknownNavigationPropertyReference";
+    ExtractorErrorCode[ExtractorErrorCode["InvalidNavigationPropertyReference"] = 4] = "InvalidNavigationPropertyReference";
+    ExtractorErrorCode[ExtractorErrorCode["MissingNavigationPropertyReference"] = 5] = "MissingNavigationPropertyReference";
+    ExtractorErrorCode[ExtractorErrorCode["MissingManyToManyUniqueId"] = 6] = "MissingManyToManyUniqueId";
+    ExtractorErrorCode[ExtractorErrorCode["MissingPrimaryKey"] = 7] = "MissingPrimaryKey";
+    ExtractorErrorCode[ExtractorErrorCode["MissingWranglerEnv"] = 8] = "MissingWranglerEnv";
+    ExtractorErrorCode[ExtractorErrorCode["TooManyWranglerEnvs"] = 9] = "TooManyWranglerEnvs";
+    ExtractorErrorCode[ExtractorErrorCode["MissingFile"] = 10] = "MissingFile";
+})(ExtractorErrorCode || (ExtractorErrorCode = {}));
+const errorInfoMap = {
+    [ExtractorErrorCode.UnknownType]: {
+        description: "Encountered an unknown or unsupported type",
+        suggestion: "Refer to the documentation on valid Cloesce TS types",
+    },
+    [ExtractorErrorCode.MultipleGenericType]: {
+        description: "Cloesce does not yet support types with multiple generics",
+        suggestion: "Simplify your type to use only a single generic parameter, ie Foo<T>",
+    },
+    [ExtractorErrorCode.InvalidIncludeTree]: {
+        description: "Invalid Include Tree",
+        suggestion: "Include trees must only contain references to a model's navigation properties.",
+    },
+    [ExtractorErrorCode.UnknownNavigationPropertyReference]: {
+        description: "Unknown Navigation Property Reference",
+        suggestion: "Verify that the navigation property reference model exists, or create a model.",
+    },
+    [ExtractorErrorCode.InvalidNavigationPropertyReference]: {
+        description: "Invalid Navigation Property Reference",
+        suggestion: "Ensure the navigation property points to a valid model field",
+    },
+    [ExtractorErrorCode.MissingNavigationPropertyReference]: {
+        description: "Missing Navigation Property Reference",
+        suggestion: "Navigation properties require a foreign key model attribute reference",
+    },
+    [ExtractorErrorCode.MissingManyToManyUniqueId]: {
+        description: "Missing unique id on Many to Many navigation property",
+        suggestion: "Define a unique identifier field for the Many-to-Many relationship",
+    },
+    [ExtractorErrorCode.MissingPrimaryKey]: {
+        description: "Missing primary key on a model",
+        suggestion: "Add a primary key field to your model (e.g., `id: number`)",
+    },
+    [ExtractorErrorCode.MissingWranglerEnv]: {
+        description: "Missing a wrangler environment definition in the project",
+        suggestion: "Add a @WranglerEnv class in your project.",
+    },
+    [ExtractorErrorCode.TooManyWranglerEnvs]: {
+        description: "Too many wrangler environments defined in the project",
+        suggestion: "Consolidate or remove unused @WranglerEnv's",
+    },
+    [ExtractorErrorCode.MissingFile]: {
+        description: "A specified input file could not be found",
+        suggestion: "Verify the input file path is correct",
+    },
+};
+export function getErrorInfo(code) {
+    return errorInfoMap[code];
+}
+export class ExtractorError {
+    code;
+    context;
+    snippet;
+    constructor(code) {
+        this.code = code;
+    }
+    addContext(fn) {
+        this.context = fn(this.context ?? "");
+    }
+}
+export function isNullableType(ty) {
+    return typeof ty === "object" && ty !== null && "Nullable" in ty;
+}
+export var HttpVerb;
+(function (HttpVerb) {
+    HttpVerb["GET"] = "GET";
+    HttpVerb["POST"] = "POST";
+    HttpVerb["PUT"] = "PUT";
+    HttpVerb["PATCH"] = "PATCH";
+    HttpVerb["DELETE"] = "DELETE";
+})(HttpVerb || (HttpVerb = {}));
+export function getNavigationPropertyCidlType(nav) {
+    return "OneToOne" in nav.kind
+        ? { Object: nav.model_name }
+        : { Array: { Object: nav.model_name } };
+}

package/dist/decorators.d.ts

@@ -0,0 +1,13 @@
+import type { Handler } from "./types.js";
+/** Use as @GET (no parentheses) */
+export declare function GET(_value: Handler, _ctx: ClassMethodDecoratorContext): void;
+/** Use as @POST (no parentheses) */
+export declare function POST(_value: Handler, _ctx: ClassMethodDecoratorContext): void;
+export declare function PUT(_value: Handler, _ctx: ClassMethodDecoratorContext): void;
+export declare function PATCH(_value: Handler, _ctx: ClassMethodDecoratorContext): void;
+export declare function DELETE(_value: Handler, _ctx: ClassMethodDecoratorContext): void;
+/** Class decorator (no-op) */
+export declare function D1<T extends new (...a: any[]) => object>(value: T, _ctx: ClassDecoratorContext<T>): T;
+/** Field decorator (no-op) */
+export declare function PrimaryKey(_v: undefined, _ctx: ClassFieldDecoratorContext): void;
+//# sourceMappingURL=decorators.d.ts.map

package/dist/decorators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorators.d.ts","sourceRoot":"","sources":["../src/decorators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C,mCAAmC;AACnC,wBAAgB,GAAG,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,2BAA2B,QAAI;AAE1E,oCAAoC;AACpC,wBAAgB,IAAI,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,2BAA2B,QAAI;AAE3E,wBAAgB,GAAG,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,2BAA2B,QAAI;AAE1E,wBAAgB,KAAK,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,2BAA2B,QAAI;AAE5E,wBAAgB,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,2BAA2B,QAAI;AAE7E,8BAA8B;AAC9B,wBAAgB,EAAE,CAAC,CAAC,SAAS,KAAK,GAAG,CAAC,EAAE,GAAG,EAAE,KAAK,MAAM,EACtD,KAAK,EAAE,CAAC,EACR,IAAI,EAAE,qBAAqB,CAAC,CAAC,CAAC,KAG/B;AAED,8BAA8B;AAC9B,wBAAgB,UAAU,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,0BAA0B,QAAI"}