@deterministic-code/datasources-cli 0.0.0-stage → 0.1.3

package/node_modules/@deterministic-code/generators-common/dist/routes-api-converter.js

@@ -0,0 +1,528 @@
+import pluralize from "pluralize";
+import { parse as parseYaml } from "yaml";
+import {
+  DeterministicParser
+} from "@deterministic-code/deterministic-generators-common/parser";
+import { fromSettings } from "./settings.js";
+import {
+  identityColumns,
+  primaryKeyColumn,
+  ROUTES_YAML,
+  typeHasTag
+} from "./spec-types.js";
+import {
+  ROUTES_API_VERSION
+} from "./routes-api.js";
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const namedEntries = (value) => Array.isArray(value) ? value.flatMap((item) => {
+  if (!isRecord(item)) return [];
+  const name = Object.keys(item)[0];
+  return name === void 0 ? [] : [[name, item[name]]];
+}) : [];
+const BY_FIELD_METHODS = ["GET", "PUT", "DELETE"];
+const EAGER_SUFFIXES = [
+  "_eager_body",
+  "_eager_create_body",
+  "_eager_patch_body",
+  "_eager_row",
+  "_eager_create_row"
+];
+const REF_PREFIX = "#/components/schemas/";
+const specName = (raw) => raw.replace(/-/g, "_");
+const specPlural = (name) => {
+  const parts = specName(name).split("_");
+  parts[parts.length - 1] = pluralize.plural(parts[parts.length - 1]);
+  return parts.join("_");
+};
+const camelIdent = (name) => specName(name).replace(/_([a-z0-9])/gi, (_, ch) => ch.toUpperCase());
+const pascalIdent = (name) => {
+  const camel = camelIdent(name);
+  return camel.length === 0 ? camel : camel[0].toUpperCase() + camel.slice(1);
+};
+const refString = (references) => typeof references === "string" ? references : void 0;
+const pkTypeOf = (entity, types, tables) => {
+  const type = types.find((d) => d.name === entity);
+  const table = tables.find((d) => d.name === entity);
+  const col = primaryKeyColumn(table, type);
+  return type?.fields.find((f) => f.name === col)?.type ?? "integer";
+};
+const tagged = (type, tag) => type !== void 0 && typeHasTag(type, tag);
+const isReadonlyLookup = (type) => tagged(type, "readonly_lookup");
+const isRoutedEntity = (type) => type !== void 0 && (typeHasTag(type, "datasource_type") || typeHasTag(type, "view_type")) && !typeHasTag(type, "many_to_many") && type.inherits !== "dictionary";
+const occTable = (type, table) => ({
+  ...type !== void 0 ? { tags: type.tags } : {},
+  ...table?.useOptimisticConcurrency !== void 0 ? { useOptimisticConcurrency: table.useOptimisticConcurrency } : {}
+});
+const bracePath = (path) => path.replace(/:([A-Za-z_][A-Za-z0-9_]*)/g, "{$1}");
+const TEMPLATE_SAMPLES = {
+  datetime: "2026-01-01T00:00:00Z",
+  uuid: "00000000-0000-0000-0000-000000000000",
+  binary: "",
+  boolean: false,
+  integer: 0,
+  biginteger: 0,
+  smallinteger: 0,
+  number: 0,
+  float: 0
+};
+const rec = (value) => isRecord(value) ? value : {};
+const isEagerName = (name) => EAGER_SUFFIXES.some((suffix) => name.endsWith(suffix));
+const schemaRef = (name) => ({
+  $ref: `${REF_PREFIX}${name}`
+});
+const PRIMITIVE_SCHEMA = {
+  decimal: { type: "string" },
+  number: { type: "number" },
+  integer: { type: "integer", format: "int32" },
+  smallinteger: { type: "integer", format: "int32" },
+  unsignedinteger: { type: "integer", format: "int32" },
+  unsignedsmallinteger: { type: "integer", format: "int32" },
+  biginteger: { type: "integer", format: "int64" },
+  unsignedbiginteger: { type: "integer", format: "int64" },
+  float: { type: "number", format: "float" },
+  boolean: { type: "boolean" },
+  datetime: { type: "string", format: "date-time" },
+  binary: { type: "string", format: "byte" },
+  uuid: { type: "string", format: "uuid" },
+  reference: { type: "integer" }
+};
+const schemaForPrimitive = (type, size) => {
+  if (type === "string" || type === "character") {
+    return size === void 0 ? { type: "string" } : { type: "string", maxLength: size };
+  }
+  const schema = PRIMITIVE_SCHEMA[type];
+  if (schema === void 0) {
+    throw new Error(`Unknown datasource field type: ${type}`);
+  }
+  return schema;
+};
+const converterTypeForSchema = (schema) => {
+  if (schema.format === "date-time") return "datetime";
+  if (schema.format === "byte") return "binary";
+  if (schema.format === "uuid") return "uuid";
+  if (schema.format === "int32") return "integer";
+  if (schema.format === "int64") return "biginteger";
+  if (schema.format === "float") return "float";
+  if (schema.type === "integer") return "integer";
+  if (schema.type === "number") return "number";
+  if (schema.type === "boolean") return "boolean";
+  return "string";
+};
+const fieldSchema = (field) => {
+  const references = refString(field.references);
+  let schema;
+  if (field.kind === "type") {
+    const ref = schemaRef(field.base);
+    schema = field.isArray ? { type: "array", items: ref } : ref;
+  } else if (references !== void 0 && (field.type === "reference" || field.type === void 0)) {
+    schema = { type: "integer" };
+  } else {
+    const size = typeof field.size === "number" ? field.size : void 0;
+    const inner = schemaForPrimitive(field.base, size);
+    schema = field.isArray ? { type: "array", items: inner } : inner;
+  }
+  if (field.isNullable) schema = { ...schema, nullable: true };
+  if (field.hasDefault) schema = { ...schema, default: field.defaultValue };
+  if (references !== void 0 && references.length > 0) {
+    schema = { ...schema, "x-references": references };
+  }
+  return schema;
+};
+const fieldIsRequired = (field) => field.isNullable !== true && field.hasDefault !== true;
+const buildDtoSchema = (fields, write) => {
+  const properties = {};
+  const required = [];
+  for (const field of fields) {
+    properties[field.name] = fieldSchema(field);
+    if (write ? fieldIsRequired(field) : !field.isNullable) {
+      required.push(field.name);
+    }
+  }
+  return write ? { type: "object", required, properties } : { type: "object", properties };
+};
+const buildComponents = (types, tables) => {
+  const tableByName = new Map(tables.map((d) => [d.name, d]));
+  const components = {};
+  for (const type of types) {
+    const pkNames = identityColumns(type, tableByName.get(type.name));
+    const write = type.name.startsWith("update_") || type.name.startsWith("create_") || isEagerName(type.name);
+    components[type.name] = buildDtoSchema(type.fields, write);
+    if (isRoutedEntity(type)) {
+      const updateName = `update_${type.name}`;
+      if (components[updateName] === void 0) {
+        components[updateName] = buildDtoSchema(type.fields, true);
+      }
+      if (pkNames.length !== 1 || pkNames[0] !== "id") {
+        const createName = `create_${type.name}`;
+        if (components[createName] === void 0) {
+          components[createName] = buildDtoSchema(type.fields, true);
+        }
+      }
+    }
+  }
+  return components;
+};
+const walkSchema = (schema, components, stack, depth) => {
+  if (depth > 32) return null;
+  if (typeof schema.$ref === "string") {
+    if (!schema.$ref.startsWith(REF_PREFIX)) return null;
+    const name = schema.$ref.slice(REF_PREFIX.length);
+    const seen = stack.filter((prior) => prior === name).length;
+    if (seen > 1) return name;
+    const target = components[name];
+    return target === void 0 ? name : walkSchema(target, components, [...stack, name], depth + 1);
+  }
+  if (schema.oneOf !== void 0 && schema.oneOf.length > 0) {
+    return walkSchema(schema.oneOf[0], components, stack, depth);
+  }
+  if (schema.type === "array") {
+    return [
+      walkSchema(schema.items ?? {}, components, stack, depth + 1)
+    ];
+  }
+  if (schema.type === "object" || schema.properties !== void 0) {
+    const out = {};
+    for (const [key, sub] of Object.entries(schema.properties ?? {})) {
+      out[key] = walkSchema(sub, components, stack, depth + 1);
+    }
+    return out;
+  }
+  return TEMPLATE_SAMPLES[converterTypeForSchema(schema)] ?? "string";
+};
+const resolveBody = (name, components) => {
+  if (name === void 0 || name.length === 0) return void 0;
+  if (components[name] === void 0) {
+    return { name, schema: null, example: null };
+  }
+  const schema = schemaRef(name);
+  return {
+    name,
+    schema,
+    example: walkSchema(schema, components, [], 0)
+  };
+};
+const entry = (name, def, components) => {
+  const request = resolveBody(def.request, components);
+  const response = resolveBody(def.response, components);
+  const out = {
+    path: def.path,
+    method: def.method,
+    entity: def.entity,
+    isCustom: def.isCustom
+  };
+  if (request !== void 0) out.request = request;
+  if (response !== void 0) out.response = response;
+  if (def.byField !== void 0) out.byField = def.byField;
+  if (def.byFieldUnique !== void 0) out.byFieldUnique = def.byFieldUnique;
+  if (def.primaryKeyField !== void 0) out.primaryKeyField = def.primaryKeyField;
+  if (def.primaryKeyFields !== void 0) out.primaryKeyFields = def.primaryKeyFields;
+  if (def.optimisticConcurrency === true) out.optimisticConcurrency = true;
+  return { [name]: out };
+};
+const occWrite = (table, settings) => settings.usesOptimisticConcurrency(table) ? { optimisticConcurrency: true } : {};
+const crudEntries = (candidate, args) => {
+  const entity = candidate.name;
+  const collection = args.collectionPath ?? `/api/${specPlural(entity)}`;
+  const type = args.types.find((d) => d.name === entity);
+  const table = args.tables.find((d) => d.name === entity);
+  const columns = identityColumns(type, table);
+  const column = columns[0] ?? "id";
+  const member = args.memberPath ?? `${collection}/${(columns.length > 0 ? columns : [column]).map((c) => `{${c}}`).join("/")}`;
+  const readonly = isReadonlyLookup(type);
+  const eager = args.eager.has(entity);
+  const post = eager ? `${entity}_eager_create_body` : columns.length !== 1 || column !== "id" ? `create_${entity}` : `update_${entity}`;
+  const put = eager ? `${entity}_eager_body` : `update_${entity}`;
+  const patch = eager ? `${entity}_eager_patch_body` : `update_${entity}`;
+  const camel = camelIdent(entity);
+  const meta = {
+    entity,
+    isCustom: false,
+    primaryKeyField: columns.length === 1 && column === "id" ? null : column,
+    ...columns.length > 1 ? { primaryKeyFields: columns } : {}
+  };
+  const occ = occWrite(occTable(type, table), args.settings);
+  const { components } = args;
+  const routes = [
+    entry(
+      `${camel}List`,
+      { path: collection, method: "GET", response: entity, ...meta },
+      components
+    ),
+    entry(
+      `${camel}Get`,
+      { path: member, method: "GET", response: entity, ...meta },
+      components
+    )
+  ];
+  if (readonly) return routes;
+  return [
+    ...routes,
+    entry(
+      `${camel}Create`,
+      {
+        path: collection,
+        method: "POST",
+        request: post,
+        response: entity,
+        ...meta
+      },
+      components
+    ),
+    entry(
+      `${camel}Update`,
+      {
+        path: member,
+        method: "PUT",
+        request: put,
+        response: entity,
+        ...meta,
+        ...occ
+      },
+      components
+    ),
+    entry(
+      `${camel}Patch`,
+      {
+        path: member,
+        method: "PATCH",
+        request: patch,
+        response: entity,
+        ...meta,
+        ...occ
+      },
+      components
+    ),
+    entry(
+      `${camel}Delete`,
+      { path: member, method: "DELETE", ...meta, ...occ },
+      components
+    )
+  ];
+};
+const byFieldEntries = (entity, field, readonly, components) => {
+  const methods = (field.methods ?? [...BY_FIELD_METHODS]).filter(
+    (method) => readonly ? method === "GET" : true
+  );
+  const collection = `/api/${specPlural(entity)}/${field.byField}`;
+  const member = `${collection}/{${field.byField}}`;
+  const camel = camelIdent(entity);
+  const byPascal = pascalIdent(field.byField);
+  const meta = {
+    entity,
+    isCustom: false,
+    byField: field.byField,
+    byFieldUnique: field.byFieldUnique
+  };
+  const out = [];
+  if (methods.includes("GET")) {
+    out.push(
+      entry(
+        `${camel}GetBy${byPascal}`,
+        { path: member, method: "GET", response: entity, ...meta },
+        components
+      )
+    );
+  }
+  if (methods.includes("PUT")) {
+    out.push(
+      entry(
+        `${camel}UpdateBy${byPascal}`,
+        {
+          path: member,
+          method: "PUT",
+          request: `update_${entity}`,
+          response: entity,
+          ...meta
+        },
+        components
+      )
+    );
+  }
+  if (methods.includes("DELETE")) {
+    out.push(
+      entry(
+        `${camel}DeleteBy${byPascal}`,
+        { path: member, method: "DELETE", ...meta },
+        components
+      )
+    );
+  }
+  return out;
+};
+const customEntry = (custom, components) => {
+  if (custom.path === void 0 || custom.method === void 0) {
+    return null;
+  }
+  return entry(
+    custom.name,
+    {
+      path: bracePath(custom.path),
+      method: custom.method,
+      entity: custom.entity,
+      isCustom: true,
+      request: custom.request,
+      response: custom.response
+    },
+    components
+  );
+};
+const nestedMemberSuffix = (nested, types, tables) => {
+  if (nested.kind === "m2m") return `{${nested.targetParam}}`;
+  const type = types.find((d) => d.name === nested.child.name);
+  const table = tables.find((d) => d.name === nested.child.name);
+  const cols = identityColumns(type, table);
+  return (cols.length > 0 ? cols : ["id"]).map((c) => `{${c}}`).join("/");
+};
+const nestedPaths = (nested, types, tables) => {
+  const collection = bracePath(`${nested.parentBasePath}${nested.segment}`);
+  return {
+    collection,
+    member: `${collection}/${nestedMemberSuffix(nested, types, tables)}`
+  };
+};
+const combinedPrefix = (nested) => camelIdent(nested.parent) + pascalIdent(specName(nested.segmentTail));
+const combinedEntries = (nested, components, types, tables, settings) => {
+  const { collection, member } = nestedPaths(nested, types, tables);
+  const prefix = combinedPrefix(nested);
+  if (nested.kind === "direct-fk") {
+    const child = nested.child.name;
+    const type = types.find((d) => d.name === child);
+    const table = tables.find((d) => d.name === child);
+    const occ = type === void 0 ? {} : occWrite(occTable(type, table), settings);
+    const meta2 = { entity: child, isCustom: false };
+    return {
+      extra: {},
+      routes: [
+        entry(`${prefix}List`, { path: collection, method: "GET", response: child, ...meta2 }, components),
+        entry(`${prefix}Create`, { path: collection, method: "POST", request: `update_${child}`, response: child, ...meta2 }, components),
+        entry(`${prefix}Update`, { path: member, method: "PUT", request: `update_${child}`, response: child, ...meta2, ...occ }, components),
+        entry(`${prefix}Delete`, { path: member, method: "DELETE", ...meta2, ...occ }, components)
+      ]
+    };
+  }
+  const target = nested.target;
+  const linkName = `link_${nested.junction}`;
+  const extra = {
+    [linkName]: {
+      type: "object",
+      required: [nested.childFkField],
+      properties: {
+        [nested.childFkField]: {
+          ...schemaForPrimitive(pkTypeOf(nested.target, types, tables)),
+          "x-references": `${nested.target}.id`
+        }
+      }
+    }
+  };
+  const merged = { ...components, ...extra };
+  const meta = { entity: target, isCustom: false };
+  return {
+    extra,
+    routes: [
+      entry(`${prefix}List`, { path: collection, method: "GET", response: target, ...meta }, merged),
+      entry(`${prefix}LinkByBody`, { path: collection, method: "POST", request: linkName, response: target, ...meta }, merged),
+      entry(`${prefix}Get`, { path: member, method: "GET", response: target, ...meta }, merged),
+      entry(`${prefix}Link`, { path: member, method: "POST", response: target, ...meta }, merged),
+      entry(`${prefix}Unlink`, { path: member, method: "DELETE", ...meta }, merged)
+    ]
+  };
+};
+const parentCrudEntries = (parent, parentRoute, args) => {
+  const type = args.types.find((d) => d.name === parent);
+  if (!isRoutedEntity(type)) {
+    return [];
+  }
+  const memberPath = bracePath(parentRoute);
+  const collectionPath = memberPath.replace(/(\/\{[^}]+\})+$/, "");
+  if (collectionPath === memberPath) return [];
+  return crudEntries(
+    {
+      name: parent,
+      tags: type.tags,
+      inherits: type.inherits,
+      byFields: []
+    },
+    { ...args, collectionPath, memberPath }
+  );
+};
+const eagerRoots = (includes) => {
+  const out = /* @__PURE__ */ new Set();
+  for (const [, block] of namedEntries(includes)) {
+    const paths = rec(block).eager_write_path;
+    if (!Array.isArray(paths)) continue;
+    for (const path of paths) {
+      const root = String(path).split(".")[0];
+      if (root !== void 0 && root.length > 0) out.add(root);
+    }
+  }
+  return out;
+};
+const combinedParentsWithRoute = (combined) => {
+  const out = /* @__PURE__ */ new Map();
+  for (const [name, body] of namedEntries(combined)) {
+    const route = rec(body).route;
+    if (typeof route === "string") out.set(name, route);
+  }
+  return out;
+};
+const parseRoutesApi = (args) => {
+  const components = buildComponents(args.types, args.tables);
+  const routesDoc = rec(parseYaml(args.routesYaml));
+  const eager = eagerRoots(routesDoc.includes);
+  const routedParents = combinedParentsWithRoute(routesDoc.combined_routes);
+  const routes = [];
+  const typeByName = new Map(args.types.map((t) => [t.name, t]));
+  const crudArgs = {
+    types: args.types,
+    tables: args.tables,
+    eager,
+    components,
+    settings: args.settings
+  };
+  for (const custom of args.parsed.customs) {
+    const item = customEntry(custom, components);
+    if (item !== null) routes.push(item);
+  }
+  for (const candidate of args.parsed.candidates) {
+    const type = typeByName.get(candidate.name);
+    if (!isRoutedEntity(type)) continue;
+    if (isEagerName(candidate.name)) continue;
+    if (routedParents.has(candidate.name)) continue;
+    routes.push(...crudEntries(candidate, crudArgs));
+    const readonly = isReadonlyLookup(type);
+    for (const field of candidate.byFields) {
+      routes.push(...byFieldEntries(candidate.name, field, readonly, components));
+    }
+  }
+  for (const [parent, route] of routedParents) {
+    routes.push(...parentCrudEntries(parent, route, crudArgs));
+  }
+  for (const nested of args.parsed.nested) {
+    const { routes: items, extra } = combinedEntries(
+      nested,
+      components,
+      args.types,
+      args.tables,
+      args.settings
+    );
+    Object.assign(components, extra);
+    routes.push(...items);
+  }
+  return { version: ROUTES_API_VERSION, routes, components };
+};
+const loadRoutesApi = async (ctx) => {
+  const [spec, routesYaml] = await Promise.all([
+    DeterministicParser(ctx.reader).parse(ctx.settings),
+    ctx.reader.read(ROUTES_YAML)
+  ]);
+  return parseRoutesApi({
+    parsed: spec.routes,
+    types: spec.expandedTypes,
+    tables: spec.datasource,
+    routesYaml,
+    settings: fromSettings(ctx.settings)
+  });
+};
+export {
+  loadRoutesApi
+};

package/node_modules/@deterministic-code/generators-common/dist/routes-api.d.ts

@@ -0,0 +1,57 @@
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+/** Contract version stamped on every expanded routes-api document. */
+export declare const ROUTES_API_VERSION = "1.0.0";
+/** Named JSON Schema / OpenAPI schema object in the routes-api component map. */
+export type RoutesApiSchema = {
+    type?: string;
+    format?: string;
+    properties?: Record<string, RoutesApiSchema>;
+    items?: RoutesApiSchema;
+    required?: string[];
+    $ref?: string;
+    nullable?: boolean;
+    enum?: unknown[];
+    default?: unknown;
+    maxLength?: number;
+    oneOf?: RoutesApiSchema[];
+    "x-references"?: string;
+};
+/** Resolved request/response body: component name, `$ref` schema, rendered example. */
+export type RoutesApiBody = {
+    name: string;
+    schema: {
+        $ref: string;
+    } | null;
+    example: JsonValue | null;
+};
+/** One expanded operation (CRUD, combined-route child, or custom). */
+export type RoutesApiRouteDef = {
+    path: string;
+    method: string;
+    entity: string | null;
+    isCustom: boolean;
+    request?: RoutesApiBody;
+    response?: RoutesApiBody;
+    byField?: string;
+    byFieldUnique?: boolean;
+    primaryKeyField?: string | null;
+    /** All identity columns when the entity has a composite primary key. */
+    primaryKeyFields?: string[];
+    /** When true, this write requires `If-Match: <updated>` (PUT/PATCH/DELETE). */
+    optimisticConcurrency?: boolean;
+};
+/** Single-key `{ <routeName>: def }` map. */
+export type RoutesApiRouteEntry = Record<string, RoutesApiRouteDef>;
+/**
+ * Flattened HTTP API catalog: `{ version, routes, components }`.
+ * @see https://github.com/deterministic-code/deterministic-specifications/blob/main/backend/routes-api.spec.yaml
+ */
+export type RoutesApiDoc = {
+    version: string;
+    routes: RoutesApiRouteEntry[];
+    components: Record<string, RoutesApiSchema>;
+};
+/** Flatten YAML-style single-key route maps into `[name, def]` pairs. */
+export declare const namedRoutes: (routes: RoutesApiRouteEntry[]) => Array<[string, RoutesApiRouteDef]>;

package/node_modules/@deterministic-code/generators-common/dist/routes-api.js

@@ -0,0 +1,13 @@
+const ROUTES_API_VERSION = "1.0.0";
+const namedRoutes = (routes) => routes.flatMap((item) => {
+  const name = Object.keys(item)[0];
+  const def = name === void 0 ? void 0 : item[name];
+  if (name === void 0 || def === null || typeof def !== "object" || typeof def.path !== "string" || typeof def.method !== "string") {
+    return [];
+  }
+  return [[name, def]];
+});
+export {
+  ROUTES_API_VERSION,
+  namedRoutes
+};

package/node_modules/@deterministic-code/generators-common/dist/settings.d.ts

@@ -0,0 +1,20 @@
+export type OccTable = {
+    datasourceType?: string | null;
+    optimisticConcurrency?: boolean;
+    tags?: readonly string[];
+    useOptimisticConcurrency?: boolean;
+};
+export declare const FRONTEND_FRAMEWORKS: readonly ["vite", "next", "svelte", "angular"];
+export type FrontendFramework = (typeof FRONTEND_FRAMEWORKS)[number];
+export type ISettings = {
+    readonly applicationName: string;
+    readonly frontendFramework: FrontendFramework;
+    readonly fullStack: boolean;
+    readonly schemaVersion: string;
+    readonly simpleDoc: boolean;
+    readonly descriptionDoc: boolean;
+    readonly createIndex: boolean;
+    readonly libraryReferenceMode: string | undefined;
+    usesOptimisticConcurrency(table: OccTable): boolean;
+};
+export declare const fromSettings: (raw: Record<string, string>) => ISettings;

package/node_modules/@deterministic-code/generators-common/dist/settings.js

@@ -0,0 +1,47 @@
+const FRONTEND_FRAMEWORKS = [
+  "vite",
+  "next",
+  "svelte",
+  "angular"
+];
+const isFrontendFramework = (raw) => FRONTEND_FRAMEWORKS.includes(raw);
+const fromSettings = (raw) => {
+  const comments = raw["comments"];
+  const globalOcc = raw["datasource.use_optimistic_concurrency"] !== "false";
+  const frontendFramework = raw["frontend_generate_framework"];
+  if (frontendFramework !== void 0 && frontendFramework !== "" && !isFrontendFramework(frontendFramework)) {
+    throw new Error(
+      `settings.frontend_generate_framework must be ${FRONTEND_FRAMEWORKS.map((name) => JSON.stringify(name)).join(", ")}, got ${JSON.stringify(frontendFramework)}`
+    );
+  }
+  return {
+    applicationName: raw["application_name"] || "generated-frontend",
+    frontendFramework: frontendFramework === void 0 || frontendFramework === "" ? "vite" : frontendFramework,
+    fullStack: raw["application_tier"] === "full-stack",
+    schemaVersion: raw["codegen.schema_version"] ?? "1.0",
+    simpleDoc: comments !== "none" && comments !== "description",
+    descriptionDoc: comments === "description",
+    createIndex: raw["codegen.create_index"] !== "false",
+    libraryReferenceMode: raw["languages.typescript.library_reference_mode"],
+    usesOptimisticConcurrency: (table) => {
+      const tags = table.tags ?? [];
+      if (table.datasourceType === "many-to-many" || tags.includes("many_to_many")) {
+        return false;
+      }
+      if (table.datasourceType === "readonly-lookup" || tags.includes("readonly_lookup")) {
+        return false;
+      }
+      if (table.useOptimisticConcurrency !== void 0) {
+        return table.useOptimisticConcurrency;
+      }
+      if (table.optimisticConcurrency !== void 0) {
+        return table.optimisticConcurrency;
+      }
+      return globalOcc;
+    }
+  };
+};
+export {
+  FRONTEND_FRAMEWORKS,
+  fromSettings
+};