joist-codegen 2.3.0-next.42 → 2.3.0-next.44

package/build/config.d.ts

@@ -1,178 +0,0 @@
-import { z } from "zod";
-import { DbMetadata, Entity, EntityDbMetadata } from "./EntityDbMetadata";
-declare const fieldConfig: z.ZodObject<{
-    derived: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"sync">, z.ZodLiteral<"async">]>>;
-    protected: z.ZodOptional<z.ZodBoolean>;
-    ignore: z.ZodOptional<z.ZodBoolean>;
-    superstruct: z.ZodOptional<z.ZodString>;
-    zodSchema: z.ZodOptional<z.ZodString>;
-    type: z.ZodOptional<z.ZodString>;
-    serde: z.ZodOptional<z.ZodString>;
-    stiDiscriminator: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    stiType: z.ZodOptional<z.ZodString>;
-    notNull: z.ZodOptional<z.ZodBoolean>;
-    hasDefault: z.ZodOptional<z.ZodBoolean>;
-    lazy: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strict>;
-export type FieldConfig = z.infer<typeof fieldConfig>;
-declare const relationConfig: z.ZodObject<{
-    derived: z.ZodOptional<z.ZodLiteral<"async">>;
-    polymorphic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"notNull">, z.ZodLiteral<true>]>>;
-    large: z.ZodOptional<z.ZodBoolean>;
-    orderBy: z.ZodOptional<z.ZodString>;
-    softDeletes: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"include">, z.ZodLiteral<"exclude">]>>;
-    stiType: z.ZodOptional<z.ZodString>;
-    subType: z.ZodOptional<z.ZodString>;
-    skipRecursiveRelations: z.ZodOptional<z.ZodBoolean>;
-    notNull: z.ZodOptional<z.ZodBoolean>;
-    hasDefault: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strict>;
-export type RelationConfig = z.infer<typeof relationConfig>;
-declare const entityConfig: z.ZodObject<{
-    tag: z.ZodString;
-    tableName: z.ZodOptional<z.ZodString>;
-    fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        derived: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"sync">, z.ZodLiteral<"async">]>>;
-        protected: z.ZodOptional<z.ZodBoolean>;
-        ignore: z.ZodOptional<z.ZodBoolean>;
-        superstruct: z.ZodOptional<z.ZodString>;
-        zodSchema: z.ZodOptional<z.ZodString>;
-        type: z.ZodOptional<z.ZodString>;
-        serde: z.ZodOptional<z.ZodString>;
-        stiDiscriminator: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-        stiType: z.ZodOptional<z.ZodString>;
-        notNull: z.ZodOptional<z.ZodBoolean>;
-        hasDefault: z.ZodOptional<z.ZodBoolean>;
-        lazy: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strict>>>;
-    relations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        derived: z.ZodOptional<z.ZodLiteral<"async">>;
-        polymorphic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"notNull">, z.ZodLiteral<true>]>>;
-        large: z.ZodOptional<z.ZodBoolean>;
-        orderBy: z.ZodOptional<z.ZodString>;
-        softDeletes: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"include">, z.ZodLiteral<"exclude">]>>;
-        stiType: z.ZodOptional<z.ZodString>;
-        subType: z.ZodOptional<z.ZodString>;
-        skipRecursiveRelations: z.ZodOptional<z.ZodBoolean>;
-        notNull: z.ZodOptional<z.ZodBoolean>;
-        hasDefault: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strict>>>;
-    abstract: z.ZodOptional<z.ZodBoolean>;
-    orderBy: z.ZodOptional<z.ZodString>;
-    uniqueBy: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodArray<z.ZodString>>]>, z.ZodTransform<string[][], string | string[] | string[][]>>>;
-}, z.core.$strict>;
-export type EntityConfig = z.infer<typeof entityConfig>;
-declare const timestampConfig: z.ZodObject<{
-    names: z.ZodArray<z.ZodString>;
-    required: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strict>;
-export type TimestampConfig = z.infer<typeof timestampConfig>;
-export declare const config: z.ZodObject<{
-    databaseUrl: z.ZodOptional<z.ZodString>;
-    contextType: z.ZodOptional<z.ZodString>;
-    transactionType: z.ZodOptional<z.ZodString>;
-    timestampColumns: z.ZodOptional<z.ZodObject<{
-        createdAt: z.ZodOptional<z.ZodObject<{
-            names: z.ZodArray<z.ZodString>;
-            required: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strict>>;
-        updatedAt: z.ZodOptional<z.ZodObject<{
-            names: z.ZodArray<z.ZodString>;
-            required: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strict>>;
-        deletedAt: z.ZodOptional<z.ZodObject<{
-            names: z.ZodArray<z.ZodString>;
-            required: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strict>>;
-    }, z.core.$strip>>;
-    temporal: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
-        timeZone: z.ZodString;
-    }, z.core.$strip>]>>;
-    createFlushFunction: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
-    entitiesDirectory: z.ZodDefault<z.ZodString>;
-    codegenPlugins: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    entities: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
-        tag: z.ZodString;
-        tableName: z.ZodOptional<z.ZodString>;
-        fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-            derived: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"sync">, z.ZodLiteral<"async">]>>;
-            protected: z.ZodOptional<z.ZodBoolean>;
-            ignore: z.ZodOptional<z.ZodBoolean>;
-            superstruct: z.ZodOptional<z.ZodString>;
-            zodSchema: z.ZodOptional<z.ZodString>;
-            type: z.ZodOptional<z.ZodString>;
-            serde: z.ZodOptional<z.ZodString>;
-            stiDiscriminator: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-            stiType: z.ZodOptional<z.ZodString>;
-            notNull: z.ZodOptional<z.ZodBoolean>;
-            hasDefault: z.ZodOptional<z.ZodBoolean>;
-            lazy: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strict>>>;
-        relations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-            derived: z.ZodOptional<z.ZodLiteral<"async">>;
-            polymorphic: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"notNull">, z.ZodLiteral<true>]>>;
-            large: z.ZodOptional<z.ZodBoolean>;
-            orderBy: z.ZodOptional<z.ZodString>;
-            softDeletes: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"include">, z.ZodLiteral<"exclude">]>>;
-            stiType: z.ZodOptional<z.ZodString>;
-            subType: z.ZodOptional<z.ZodString>;
-            skipRecursiveRelations: z.ZodOptional<z.ZodBoolean>;
-            notNull: z.ZodOptional<z.ZodBoolean>;
-            hasDefault: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strict>>>;
-        abstract: z.ZodOptional<z.ZodBoolean>;
-        orderBy: z.ZodOptional<z.ZodString>;
-        uniqueBy: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodArray<z.ZodString>>]>, z.ZodTransform<string[][], string | string[] | string[][]>>>;
-    }, z.core.$strict>>>;
-    ignoredTables: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    idType: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"tagged-string">, z.ZodLiteral<"untagged-string">, z.ZodLiteral<"number">]>>;
-    tagDelimiter: z.ZodOptional<z.ZodString>;
-    nonDeferredForeignKeys: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"error">, z.ZodLiteral<"warn">, z.ZodLiteral<"ignore">]>>;
-    esm: z.ZodOptional<z.ZodBoolean>;
-    paginationStyle: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"cursor">, z.ZodLiteral<"limit">]>>>;
-    docs: z.ZodOptional<z.ZodBoolean>;
-    skills: z.ZodOptional<z.ZodBoolean>;
-    outputDocs: z.ZodOptional<z.ZodBoolean>;
-    allowImportingTsExtensions: z.ZodOptional<z.ZodBoolean>;
-    codemodVersion: z.ZodDefault<z.ZodNumber>;
-    schemas: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strict>;
-export type Config = z.infer<typeof config> & {
-    __tableToEntityName?: Record<string, string>;
-};
-export declare const ormMaintainedFields: string[];
-/** Ensure the user doesn't have any typos in their config. */
-export declare function warnInvalidConfigEntries(config: Config, db: DbMetadata): void;
-export declare function isGetterField(config: Config, entity: Entity, fieldName: string): boolean;
-export declare function isReactiveField(config: Config, entity: Entity, fieldName: string): boolean;
-export declare function isReactiveReference(config: Config, entity: Entity, fieldName: string): boolean;
-/** Returns true if this m2m relation is configured as a ReactiveManyToMany (derived: async). */
-export declare function isReactiveManyToMany(config: Config, entity: Entity, fieldName: string): boolean;
-export declare function isProtected(config: Config, entity: Entity, fieldName: string): boolean;
-/** Whether a column should be excluded from the default SELECT and exposed as a lazy-loaded `LazyField`. */
-export declare function isLazyField(config: Config, entity: Entity, fieldName: string): boolean;
-export declare function serdeConfig(config: Config, entity: Entity, fieldName: string): string | undefined;
-export declare function superstructConfig(config: Config, entity: Entity, fieldName: string): string | undefined;
-export declare function zodSchemaConfig(config: Config, entity: Entity, fieldName: string): string | undefined;
-export declare function fieldTypeConfig(config: Config, entity: Entity, fieldName: string): string | undefined;
-export declare function isLargeCollection(config: Config, entity: Entity, fieldName: string): boolean;
-/** Whether a collection should include (or exclude) soft-deleted entities from `.get`/`.load`. */
-export declare function softDeletesConfig(config: Config, entity: Entity, fieldName: string): "include" | "exclude" | undefined;
-export declare function isFieldIgnored(config: Config, entity: Entity, fieldName: string, notNull?: boolean, hasDefault?: boolean): boolean;
-export declare function isFieldHasDefault(config: Config, entity: Entity, fieldName: string): boolean;
-export declare function loadConfig(): Promise<Config>;
-/**
- * Writes the potentially-updated config entry back to `joist-config.json`.
- *
- * We format the output with prettier so it should both a) look nice and b) be deterministic,
- * such that no changes to the config show up as noops to the scm.
- */
-export declare function writeConfig(config: Config): Promise<void>;
-export declare function stripStiPlaceholders(config: Config, entities: EntityDbMetadata[]): void;
-/** Applies defaults to the timestamp config. */
-export declare function getTimestampConfig(config: Config): {
-    updatedAtConf: Required<TimestampConfig>;
-    createdAtConf: Required<TimestampConfig>;
-    deletedAtConf: Required<TimestampConfig>;
-};
-export {};

package/build/docs/cache.d.ts

@@ -1,13 +0,0 @@
-/** A simple mtime-based cache for docs syncing, to skip processing when neither .ts nor .md has changed. */
-export declare class DocsCache {
-    #private;
-    private constructor();
-    static load(): Promise<DocsCache>;
-    /** Returns true if both file mtimes match the cached values (i.e. skip processing). */
-    isUpToDate(entityName: string, tsMtime: number, mdMtime: number): boolean;
-    /** Record the current mtimes for an entity after processing it. */
-    update(entityName: string, tsMtime: number, mdMtime: number): void;
-    save(): Promise<void>;
-}
-/** Stat a file and return its mtimeMs, or -1 if it doesn't exist. */
-export declare function getMtime(filePath: string): Promise<number>;

package/build/docs/generate-metadata-docs.d.ts

@@ -1,5 +0,0 @@
-import { CodegenFile } from "ts-poet";
-import { DbMetadata } from "../EntityDbMetadata";
-import { type ParsedDoc } from "./markdown";
-/** Creates the `metadata-docs.ts` runtime artifact to access docs. */
-export declare function generateMetadataDocsFile(dbMeta: DbMetadata, docsByEntity: Record<string, ParsedDoc>): CodegenFile;

package/build/docs/index.d.ts

@@ -1,13 +0,0 @@
-import { type ParsedDoc } from "./markdown";
-export { generateMetadataDocsFile } from "./generate-metadata-docs";
-export { type ParsedDoc } from "./markdown";
-export { buildJSDocBlock, generatedTag } from "./parsing";
-/** Loads each entity's parsed `.md` doc, i.e. for injecting into codegen JSDocs & runtime metadata. */
-export declare function loadEntityDocs(entitiesDir: string, entityNames: string[]): Promise<Record<string, ParsedDoc>>;
-/**
- * Run the full docs sync pipeline with mtime-based caching:
- * 1. backfill .md from .ts JSDocs
- * 2. sync .md back into .ts JSDocs
- * 3. save the cache
- */
-export declare function syncDocs(entitiesDir: string, entityNames: string[]): Promise<void>;

package/build/docs/parsing.d.ts

@@ -1,45 +0,0 @@
-import type { namedTypes } from "ast-types";
-import { ASTNode } from "jscodeshift";
-type CommentKind = (namedTypes.CommentBlock | namedTypes.CommentLine | namedTypes.Block | namedTypes.Line) & {
-    start?: number;
-    end?: number;
-};
-type Commented = ASTNode & {
-    comments?: CommentKind[] | null;
-    start?: number;
-    end?: number;
-    loc?: namedTypes.SourceLocation | null;
-};
-export type MemberKind = "property" | "getter" | "setter" | "method";
-export interface MemberInfo {
-    kind: MemberKind;
-    name: string;
-    doc: string | undefined;
-    node: Commented;
-}
-export interface SourceEdit {
-    start: number;
-    end: number;
-    text: string;
-}
-/** Parse an entity .ts file and extract class + member JSDoc. */
-export declare function parseEntityJSDocs(source: string): {
-    classDoc: string | undefined;
-    classNode: Commented | undefined;
-    members: MemberInfo[];
-    fieldDocs: Record<string, string>;
-};
-/**
- * Build a source edit that sets the JSDoc on a node (replacing existing or inserting new).
- *
- * (This is bizarre, but this `SourceEdit` + `applyEdits` leaves all existing formatting
- * alone better than doing a `node.toSource()` or other AST-based updates. :grimmacing:)
- */
-export declare function buildJSDocEdit(node: Commented, text: string): SourceEdit;
-/** Apply edits to source by splicing in reverse order. */
-export declare function applyEdits(source: string, edits: SourceEdit[]): string;
-/** Build a JSDoc block comment string from plain text. */
-export declare function buildJSDocBlock(text: string, indent: number): string;
-/** The `@generated Entity.md` marker, i.e. so readers know a JSDoc is sourced from (and edited in) the `.md`. */
-export declare function generatedTag(entityName: string): string;
-export {};

package/build/findEntityScopes.d.ts

@@ -1,10 +0,0 @@
-import { type Config } from "./config";
-import { type Entity } from "./EntityDbMetadata";
-/** Each `static active = ...` scope in an entity. */
-export interface ScopeMember {
-    name: string;
-    type: string;
-}
-export type ScopeMembersByEntity = Record<string, ScopeMember[]>;
-/** Finds static scope declarations for all entity files. */
-export declare function findAllEntityScopes(config: Config, entities: Entity[]): Promise<ScopeMembersByEntity>;

package/build/foreignKeyOrdering.d.ts

@@ -1,2 +0,0 @@
-import { Config, EntityDbMetadata } from "./index";
-export declare function maybeSetForeignKeyOrdering(config: Config, entities: EntityDbMetadata[]): Promise<void>;

package/build/generate.d.ts

@@ -1,11 +0,0 @@
-import { CodegenFile } from "ts-poet";
-import { Config, DbMetadata } from "./index";
-export type DPrintOptions = Record<string, unknown>;
-/**
- * Provides an API for hooking into the codegen build step.
- */
-export interface CodegenPlugin {
-    run(config: Config, dbMeta: DbMetadata): Promise<CodegenFile>;
-}
-/** Generates our `${Entity}` and `${Entity}Codegen` files based on the `db` schema. */
-export declare function generateFiles(config: Config, dbMeta: DbMetadata): Promise<CodegenFile[]>;

package/build/generateEntitiesFile.d.ts

@@ -1,6 +0,0 @@
-import { Table } from "pg-structure";
-import { Code } from "ts-poet";
-import { Config } from "./config";
-import { EntityDbMetadata } from "./EntityDbMetadata";
-import { PgEnumData } from "./index";
-export declare function generateEntitiesFile(config: Config, entities: EntityDbMetadata[], enums: Table[], pgEnums: PgEnumData[]): Code;

package/build/generateEntityCodegenFile.d.ts

@@ -1,11 +0,0 @@
-import { Code } from "ts-poet";
-import { type Config } from "./config";
-import { type ParsedDoc } from "./docs";
-import { DbMetadata, EntityDbMetadata, PrimitiveTypescriptType } from "./EntityDbMetadata";
-import { type ScopeMember } from "./findEntityScopes";
-export interface ColumnMetaData {
-    fieldType: PrimitiveTypescriptType;
-}
-/** Creates the base class with the boilerplate annotations. */
-export declare function generateEntityCodegenFile(config: Config, dbMeta: DbMetadata, meta: EntityDbMetadata, scopeMembers?: ScopeMember[], docs?: ParsedDoc): Code;
-export declare function getIdType(config: Config): "number" | "string";

package/build/generateEntityFile.d.ts

@@ -1,5 +0,0 @@
-import { Code } from "ts-poet";
-import { Config } from "./config";
-import { EntityDbMetadata } from "./EntityDbMetadata";
-/** Creates the placeholder file for our per-entity custom business logic in. */
-export declare function generateEntityFile(config: Config, meta: EntityDbMetadata): Code;

package/build/generateEntityTestFile.d.ts

@@ -1,5 +0,0 @@
-import { Code } from "ts-poet";
-import { Config } from "./config";
-import { EntityDbMetadata } from "./EntityDbMetadata";
-/** Creates the placeholder file for our entity's test. */
-export declare function generateEntityTestFile(config: Config, meta: EntityDbMetadata): Code;

package/build/generateEnumFile.d.ts

@@ -1,4 +0,0 @@
-import { Code } from "ts-poet";
-import { Config } from "./config";
-import { EnumTableData } from "./index";
-export declare function generateEnumFile(config: Config, enumData: EnumTableData, enumName: string): Code;

package/build/generateFactoriesFiles.d.ts

@@ -1,3 +0,0 @@
-import { CodegenFile } from "ts-poet";
-import { EntityDbMetadata } from "./EntityDbMetadata";
-export declare function generateFactoriesFiles(entities: EntityDbMetadata[]): CodegenFile[];

package/build/generateMetadataFile.d.ts

@@ -1,4 +0,0 @@
-import { Code } from "ts-poet";
-import { Config } from "./config";
-import { DbMetadata, EntityDbMetadata } from "./EntityDbMetadata";
-export declare function generateMetadataFile(config: Config, dbMeta: DbMetadata, meta: EntityDbMetadata): Code;

package/build/generatePgEnumFile.d.ts

@@ -1,4 +0,0 @@
-import { Code } from "ts-poet";
-import { Config } from "./config";
-import { PgEnumData } from "./index";
-export declare function generatePgEnumFile(config: Config, enumData: PgEnumData): Code;

package/build/index.d.ts

@@ -1,11 +0,0 @@
-#!/usr/bin/env node
-import { Config } from "./config";
-import { DbMetadata, EntityDbMetadata } from "./EntityDbMetadata";
-import { mapSimpleDbTypeToTypescriptType } from "./utils";
-export { DbMetadata, EnumField, makeEntity, ManyToManyField, ManyToOneField, OneToManyField, OneToOneField, PolymorphicField, PrimitiveField, PrimitiveTypescriptType, } from "./EntityDbMetadata";
-export { EnumMetadata, EnumRow, EnumTableData, PgEnumData, PgEnumMetadata } from "./loadMetadata";
-export { Config, EntityDbMetadata, mapSimpleDbTypeToTypescriptType };
-export declare function joistCodegen(): Promise<void>;
-/** Uses entities and enums from the `db` schema and saves them into our entities directory. */
-export declare function generateAndSaveFiles(config: Config, dbMeta: DbMetadata): Promise<void>;
-export declare function maybeSetExitCode(): void;

package/build/inheritance.d.ts

@@ -1,9 +0,0 @@
-import { Config } from "./config";
-import { DbMetadata, EntityDbMetadata } from "./EntityDbMetadata";
-export declare function applyInheritanceUpdates(config: Config, db: DbMetadata): void;
-type StiEntityMap = Map<string, {
-    base: EntityDbMetadata;
-    subTypes: EntityDbMetadata[];
-}>;
-export declare function getStiEntities(entities: EntityDbMetadata[]): StiEntityMap;
-export {};

package/build/keywords.d.ts

@@ -1 +0,0 @@
-export declare const keywords: string[];

package/build/loadMetadata.d.ts

@@ -1,25 +0,0 @@
-import { Client } from "pg";
-import { Db, Table } from "pg-structure";
-import { Config, PrimitiveField } from "./index";
-/** A map from Enum table name to the rows currently in the table. */
-export type EnumTableData = {
-    table: Table;
-    idType: "integer" | "uuid";
-    name: string;
-    rows: EnumRow[];
-    extraPrimitives: PrimitiveField[];
-};
-export type PgEnumData = {
-    name: string;
-    values: string[];
-};
-export type EnumMetadata = Record<string, EnumTableData>;
-export type PgEnumMetadata = Record<string, PgEnumData>;
-export type EnumRow = {
-    id: number;
-    code: string;
-    name: string;
-    [key: string]: any;
-};
-export declare function loadEnumMetadata(db: Db, client: Client, config: Config): Promise<EnumMetadata>;
-export declare function loadPgEnumMetadata(db: Db, client: Client, config: Config): Promise<PgEnumMetadata>;

package/build/logger.d.ts

@@ -1,9 +0,0 @@
-export declare const LOG_LEVELS: {
-    warn: number;
-    error: number;
-};
-export declare let loggerMaxWarningLevelHit: number;
-export declare const logger: {
-    warn(...args: Parameters<(typeof console)["warn"]>): void;
-    error(...args: Parameters<(typeof console)["error"]>): void;
-};

package/build/scanEntityFiles.d.ts

@@ -1,4 +0,0 @@
-import { Config } from "./config";
-import { DbMetadata } from "./EntityDbMetadata";
-/** Scans the entity files themselves for usage hints (like `setDefault` calls) to drive our codegen output. */
-export declare function scanEntityFiles(config: Config, dbMeta: DbMetadata): Promise<void>;

package/build/symbols.d.ts

@@ -1,110 +0,0 @@
-export declare const ProjectEntity: import("ts-poet").Import;
-export declare const EntityManager: import("ts-poet").Import;
-export declare const ConfigApi: import("ts-poet").Import;
-export declare const newScopeFn: import("ts-poet").Import;
-export declare const Scope: import("ts-poet").Import;
-export declare const FieldStatus: import("ts-poet").Import;
-export declare const Entity: import("ts-poet").Import;
-export declare const BaseEntity: import("ts-poet").Import;
-export declare const Flavor: import("ts-poet").Import;
-export declare const Reference: import("ts-poet").Import;
-export declare const Collection: import("ts-poet").Import;
-export declare const EnumCollection: import("ts-poet").Import;
-export declare const LargeCollection: import("ts-poet").Import;
-export declare const OneToManyCollection: import("ts-poet").Import;
-export declare const JoistEntityManager: import("ts-poet").Import;
-export declare const EntityMetadata: import("ts-poet").Import;
-export declare const EnumMetadata: import("ts-poet").Import;
-export declare const Lens: import("ts-poet").Import;
-export declare const KeySerde: import("ts-poet").Import;
-export declare const ManyToOneReference: import("ts-poet").Import;
-export declare const LazyField: import("ts-poet").Import;
-export declare const hasLazyField: import("ts-poet").Import;
-export declare const ReadOnlyCollection: import("ts-poet").Import;
-export declare const PolymorphicReference: import("ts-poet").Import;
-export declare const OneToOneReference: import("ts-poet").Import;
-export declare const ManyToManyCollection: import("ts-poet").Import;
-export declare const EnumFieldSerde: import("ts-poet").Import;
-export declare const EnumArrayFieldSerde: import("ts-poet").Import;
-export declare const PolymorphicKeySerde: import("ts-poet").Import;
-export declare const PrimitiveSerde: import("ts-poet").Import;
-export declare const BigIntSerde: import("ts-poet").Import;
-export declare const DateSerde: import("ts-poet").Import;
-export declare const PlainDateSerde: import("ts-poet").Import;
-export declare const PlainTimeSerde: import("ts-poet").Import;
-export declare const PlainDateTimeSerde: import("ts-poet").Import;
-export declare const ZonedDateTimeSerde: import("ts-poet").Import;
-export declare const JsonSerde: import("ts-poet").Import;
-export declare const SuperstructSerde: import("ts-poet").Import;
-export declare const TaggedId: import("ts-poet").Import;
-export declare const ZodSerde: import("ts-poet").Import;
-export declare const CustomSerdeAdapter: import("ts-poet").Import;
-export declare const DecimalToNumberSerde: import("ts-poet").Import;
-export declare const fail: import("ts-poet").Import;
-export declare const failNoIdYet: import("ts-poet").Import;
-export declare const setOpts: import("ts-poet").Import;
-export declare const getField: import("ts-poet").Import;
-export declare const setField: import("ts-poet").Import;
-export declare const OrderBy: import("ts-poet").Import;
-export declare const OptsOf: import("ts-poet").Import;
-export declare const FieldsOf: import("ts-poet").Import;
-export declare const RelationsOf: import("ts-poet").Import;
-export declare const IdOf: import("ts-poet").Import;
-export declare const PartialOrNull: import("ts-poet").Import;
-export declare const DeepPartialOrNull: import("ts-poet").Import;
-export declare const BooleanFilter: import("ts-poet").Import;
-export declare const ValueFilter: import("ts-poet").Import;
-export declare const EntityFilter: import("ts-poet").Import;
-export declare const BooleanGraphQLFilter: import("ts-poet").Import;
-export declare const EntityGraphQLFilter: import("ts-poet").Import;
-export declare const EnumGraphQLFilter: import("ts-poet").Import;
-export declare const ValueGraphQLFilter: import("ts-poet").Import;
-export declare const FilterOf: import("ts-poet").Import;
-export declare const GraphQLFilterOf: import("ts-poet").Import;
-export declare const JsonHint: import("ts-poet").Import;
-export declare const ToJsonHint: import("ts-poet").Import;
-export declare const JsonPayload: import("ts-poet").Import;
-export declare const configureMetadata: import("ts-poet").Import;
-export declare const newRequiredRule: import("ts-poet").Import;
-export declare const newRequiredLazyFieldRule: import("ts-poet").Import;
-export declare const cannotBeUpdated: import("ts-poet").Import;
-export declare const mustBeSubType: import("ts-poet").Import;
-export declare const cleanStringValue: import("ts-poet").Import;
-export declare const Changes: import("ts-poet").Import;
-export declare const newChangesProxy: import("ts-poet").Import;
-export declare const LoadHint: import("ts-poet").Import;
-export declare const Loaded: import("ts-poet").Import;
-export declare const isLoaded: import("ts-poet").Import;
-export declare const getInstanceData: import("ts-poet").Import;
-export declare const isEntity: import("ts-poet").Import;
-export declare const loadLens: import("ts-poet").Import;
-export declare const hasOneThrough: import("ts-poet").Import;
-export declare const hasMany: import("ts-poet").Import;
-export declare const hasLargeMany: import("ts-poet").Import;
-export declare const hasOne: import("ts-poet").Import;
-export declare const hasRecursiveChildren: import("ts-poet").Import;
-export declare const hasRecursiveM2m: import("ts-poet").Import;
-export declare const hasRecursiveParents: import("ts-poet").Import;
-export declare const hasOnePolymorphic: import("ts-poet").Import;
-export declare const hasOneToOne: import("ts-poet").Import;
-export declare const hasManyToMany: import("ts-poet").Import;
-export declare const hasEnumCollection: import("ts-poet").Import;
-export declare const hasLargeManyToMany: import("ts-poet").Import;
-export declare const newTestInstance: import("ts-poet").Import;
-export declare const New: import("ts-poet").Import;
-export declare const DeepNew: import("ts-poet").Import;
-export declare const FactoryOpts: import("ts-poet").Import;
-export declare const SSAssert: import("ts-poet").Import;
-export declare const Zod: import("ts-poet").Import;
-export declare const EntityConstructor: import("ts-poet").Import;
-export declare const MaybeAbstractEntityConstructor: import("ts-poet").Import;
-export declare const deTagId: import("ts-poet").Import;
-export declare const toIdOf: import("ts-poet").Import;
-export declare const toJSON: import("ts-poet").Import;
-export declare const ReactiveField: import("ts-poet").Import;
-export declare const ReactiveReference: import("ts-poet").Import;
-export declare const ReactiveManyToMany: import("ts-poet").Import;
-export declare const ReactiveManyToManyOtherSide: import("ts-poet").Import;
-export declare const hasReactiveManyToManyOtherSide: import("ts-poet").Import;
-export declare const updatePartial: import("ts-poet").Import;
-export declare const setRuntimeConfig: import("ts-poet").Import;

package/build/tsdoc.d.ts

@@ -1,11 +0,0 @@
-export declare const tsdocComments: {
-    entity: {
-        setPartial: string;
-        setDeepPartial: string;
-        changes: string;
-        load: string;
-        populate: string;
-        isLoaded: string;
-        toJSON: string;
-    };
-};

package/build/utils.d.ts

@@ -1,30 +0,0 @@
-import { Table } from "pg-structure";
-import { Config } from "./config";
-import { DatabaseColumnType, PrimitiveTypescriptType } from "./EntityDbMetadata";
-export declare function assertNever(x: never): never;
-export declare function isEntityTable(config: Config, t: Table): boolean;
-export declare function isSubClassTable(t: Table): boolean;
-export declare function isEnumTable(config: Config, t: Table): boolean;
-export declare function isJoinTable(config: Config, t: Table): boolean;
-/** Whether a join table has a surrogate `id` primary key (vs. an id-less FK-pair composite PK). */
-export declare function joinTableHasId(t: Table): boolean;
-/** Converts `projects` to `Project`. */
-export declare function tableToEntityName(config: Config, table: Table): string;
-export declare const dateCode: import("ts-poet").Code;
-export declare const plainDateCode: import("ts-poet").Code;
-export declare const plainTimeCode: import("ts-poet").Code;
-export declare const plainDateTimeCode: import("ts-poet").Code;
-export declare const zonedDateTimeCode: import("ts-poet").Code;
-/** Maps db types, i.e. `int`, to JS types, i.e. `number`. */
-export declare function mapSimpleDbTypeToTypescriptType(config: Config, dbType: DatabaseColumnType): PrimitiveTypescriptType;
-export declare function merge<T>(a: T[], b: T[]): T[];
-/** Returns true if `p` is resolved, otherwise false if it is rejected. */
-export declare function trueIfResolved(p: Promise<unknown>): Promise<boolean>;
-export declare function fail(message?: string): never;
-export declare function sortKeys<T extends object>(o: T): T;
-export declare function parseOrder(order: string | undefined): {
-    field: string;
-    direction: "ASC" | "DESC";
-} | undefined;
-export declare function q(s: string | undefined): string;
-export declare function uncapitalize(s: string): string;

package/build/write-json-schema.d.ts

@@ -1 +0,0 @@
-export {};