ormbridge 0.7.0 → 0.9.0

package/dist/emitters/efcoreTypes.d.ts

@@ -0,0 +1,114 @@
+import type { IrCompositeForeignKey, IrField, IrModel, IrRelation, IrSchema } from '../ir.js';
+import type { ColumnSpec, EnumPlan } from './efcoreColumns.js';
+import type { PrismaProvider } from './prisma.js';
+/** The shapes the planning and rendering steps of the EF Core emitter share. */
+export type EfcoreStyle = 'annotations' | 'fluent';
+/** One property that is a database column: a field, or the foreign key column of a relation. */
+export interface ColumnMember {
+    property: string;
+    spec: ColumnSpec;
+    /** True when the column is part of the primary key. */
+    isKey: boolean;
+    /** The IR field, for a field. */
+    fieldName?: string;
+    /** The IR relation, for a foreign key column. */
+    relationName?: string;
+}
+/** One navigation property. */
+export interface NavMember {
+    property: string;
+    /** The class the navigation points at. */
+    typeName: string;
+    collection: boolean;
+    /** True when a reference may be null. */
+    nullable: boolean;
+    /** Foreign key properties, for the reference navigation of the dependent side. */
+    foreignKeys?: string[];
+    /** The navigation on the other side, for `[InverseProperty]`. */
+    inverseOf?: {
+        className: string;
+        property: string;
+    };
+}
+export interface ConfigIndex {
+    properties: string[];
+    unique: boolean;
+    name?: string;
+    /** Sort order by position; empty when every column is ascending. */
+    descending: boolean[];
+    /** Access method (`gin`); only the fluent API can say it. */
+    method?: string;
+}
+/** A one-to-many or one-to-one relationship, seen from the entity that holds the foreign key. */
+export interface Link {
+    owner: ModelPlan;
+    target: ModelPlan;
+    relationName: string;
+    relation?: IrRelation;
+    composite?: IrCompositeForeignKey;
+    /** The reference navigation on the owner. */
+    nav: string;
+    /** The navigation on the target, when the relation has a related name. */
+    inverse?: string;
+    oneToOne: boolean;
+    /** Foreign key properties on the owner. */
+    foreignKeys: string[];
+    /** Referenced properties on the target when they are not its primary key. */
+    principalKeys?: string[];
+    /** The `DeleteBehavior` to write; undefined when EF Core's default is the wanted one. */
+    behavior?: string;
+    required: boolean;
+    constraintName?: string;
+    /** The key field the foreign key column copies its type from. */
+    keyField?: IrField;
+}
+export interface ManyToManyLink {
+    owner: ModelPlan;
+    target: ModelPlan;
+    relationName: string;
+    nav: string;
+    inverse?: string;
+    joinTable: string;
+    ownerColumn: string;
+    targetColumn: string;
+}
+export interface ModelPlan {
+    model: IrModel;
+    className: string;
+    /** The `DbSet` property name on the context. */
+    dbSet: string;
+    tableName: string;
+    /** True when the table name is not the `DbSet` name, so the class needs `[Table]` / `ToTable`. */
+    needsTable: boolean;
+    schema: string | undefined;
+    /** Member names in use on the class. */
+    used: Set<string>;
+    /** IR field name -> property. */
+    fieldProps: Map<string, string>;
+    /** IR relation name -> foreign key property. */
+    relationFks: Map<string, string>;
+    /** IR relation name -> navigation property. */
+    relationNavs: Map<string, string>;
+    columns: ColumnMember[];
+    navs: NavMember[];
+    /** Primary key properties, in key order. */
+    keyProps: string[];
+    keyless: boolean;
+    isView: boolean;
+    keyName: string | undefined;
+    alternateKeys: string[][];
+    indexes: ConfigIndex[];
+    links: Link[];
+    manyToMany: ManyToManyLink[];
+    /** Properties that are refreshed on every save. */
+    autoUpdated: string[];
+}
+export interface Plan {
+    schema: IrSchema;
+    style: EfcoreStyle;
+    namespace: string;
+    header: boolean;
+    provider: PrismaProvider;
+    models: ModelPlan[];
+    enums: EnumPlan[];
+}

package/dist/emitters/efcoreTypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=efcoreTypes.js.map

package/dist/emitters/efcoreTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"efcoreTypes.js","sourceRoot":"","sources":["../../src/emitters/efcoreTypes.ts"],"names":[],"mappings":""}

package/dist/emitters/sequelize.d.ts

@@ -0,0 +1,35 @@
+import type { MultiFileEmitOutput } from '../formats.js';
+import type { IrSchema } from '../ir.js';
+import { type NamingMode } from '../transforms.js';
+import type { PrismaProvider } from './prisma.js';
+/**
+ * Writes Sequelize 6 models. Both styles write one file per model plus an `index` file:
+ *
+ * - `init` (the default) is TypeScript: `class User extends Model<InferAttributes<User>, ...>` with `declare`
+ *   fields and a static `initModel(sequelize)` that calls `User.init({ ... }, { sequelize, modelName, tableName })`.
+ *   `index.ts` exports the models and an `initModels(sequelize)` function that runs every `initModel` and then
+ *   the associations (`belongsTo`, `hasMany`, `hasOne`, `belongsToMany`).
+ * - `define` is the CommonJS layout `sequelize-cli` generates: `module.exports = (sequelize, DataTypes) => ...`
+ *   with `sequelize.define(...)` and an `associate(models)` function, and an `index.js` that wires them together.
+ *
+ * Every table, column and association is written explicitly (`tableName`, `field`, `as`, `foreignKey`,
+ * `onDelete`), so the models create the schema of the IR and the Sequelize reader reads the output back.
+ */
+export type SequelizeStyle = 'init' | 'define';
+export declare const SEQUELIZE_STYLES: readonly SequelizeStyle[];
+/** True when a value is one of the Sequelize `--style` values. */
+export declare function isSequelizeStyle(value: string): value is SequelizeStyle;
+export interface SequelizeEmitOptions {
+    /** Database provider; picks the data types (JSONB vs JSON, ARRAY, INET, ...). */
+    provider: PrismaProvider;
+    /**
+     * "preserve" keeps the database names of the source: the attribute names stay as written and every
+     * `tableName` and `field` is explicit. "normalize" applies the fresh-schema style of the other emitters
+     * (singular snake_case tables, UUID keys, `created_at` / `updated_at`) with camelCase attributes over
+     * snake_case columns (`underscored: true`).
+     */
+    naming: NamingMode;
+    /** Output layout; defaults to `init`. */
+    style?: SequelizeStyle;
+}
+export declare function emitSequelize(schema: IrSchema, options: SequelizeEmitOptions): MultiFileEmitOutput;