@venizia/ignis 0.4.3 → 0.4.4

package/dist/esm/components/static-asset/ingest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ingest.js","sourceRoot":"","sources":["../../../../src/components/static-asset/ingest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AACvD,OAAO,EACL,SAAS,EACT,iBAAiB,EACjB,eAAe,GAOhB,MAAM,wBAAwB,CAAC;AA2ChC,MAAM,cAAc,GAAG,CAAC,IAAuC,EAAU,EAAE;IACzE,MAAM,EAAE,GAAG,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC;IACjC,MAAM,WAAW,GAAG,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,IAAI,QAAQ,CAAC;IAC9E,MAAM,UAAU,GAAG,WAAW,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;IAEhE,OAAO,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,IAAI,UAAU,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC;AACjE,CAAC,CAAC;AAEF,uDAAuD;AACvD,MAAM,OAAO,WAAW;IACtB;;;;;;;;;;OAUG;IACH,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,IAA2B;QAC9C,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,eAAe,EAAE,GAAG,IAAI,CAAC;QAEtF,MAAM,QAAQ,GAAG,MAAM,SAAS,CAAC,YAAY,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,CAAC;QAC/D,MAAM,UAAU,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;QACrF,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC;QAE5B,MAAM,GAAG,GAAG,UAAU;YACpB,CAAC,CAAC,UAAU,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,WAAW,EAAE,UAAU,EAAE,CAAC;YACtD,CAAC,CAAC,cAAc,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC,CAAC;QAEhD,8FAA8F;QAC9F,gEAAgE;QAChE,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,EAAE,QAAQ,EAAE,IAAI,CAAC,cAAc,EAAE,CAAC,EAAE,CAAC;YACjF,MAAM,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC;YAC9B,MAAM,QAAQ,CAAC,EAAE,OAAO,EAAE,mDAAmD,GAAG,EAAE,EAAE,CAAC,CAAC;QACxF,CAAC;QAED,4FAA4F;QAC5F,+FAA+F;QAC/F,iGAAiG;QACjG,iEAAiE;QACjE,MAAM,cAAc,GAAG,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC,CAAC;QAC3E,MAAM,QAAQ,GAAG,MAAM,EAAE,QAAQ,IAAI,iBAAiB,CAAC,SAAS,CAAC;QAEjE,IAAI,cAAc,GAAG,QAAQ,EAAE,CAAC;YAC9B,MAAM,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC;YAC9B,MAAM,QAAQ,CAAC;gBACb,KAAK,EAAE,eAAe,CAAC,WAAW;gBAClC,OAAO,EAAE,0DAA0D,cAAc,WAAW,QAAQ,EAAE;aACvG,CAAC,CAAC;QACL,CAAC;QAED,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;YACnB,MAAM,QAAQ,CAAC,EAAE,OAAO,EAAE,yDAAyD,GAAG,EAAE,EAAE,CAAC,CAAC;QAC9F,CAAC;QAED,MAAM,MAAM,GAAe,EAAE,GAAG,EAAE,CAAC;QACnC,MAAM,WAAW,GAAG,MAAM,CAAC,WAAW,CAAC,EAAE,QAAQ,EAAE,GAAG,EAAE,CAAC,CAAC;QAE1D,MAAM,MAAM,CAAC,WAAW,CAAC;YACvB,MAAM;YACN,MAAM;YACN,MAAM,EAAE,SAAS,CAAC,SAAS,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,CAAC;YAC9D,WAAW;YACX,cAAc,EAAE,IAAI,CAAC,cAAc;SACpC,CAAC,CAAC;QAEH,MAAM,IAAI,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;QACtD,MAAM,IAAI,GAAG,eAAe,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;QAEjD,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,MAAM,QAAQ,CAAC;gBACb,OAAO,EAAE,uEAAuE,GAAG,EAAE;aACtF,CAAC,CAAC;QACL,CAAC;QAED,OAAO;YACL,MAAM,EAAE;gBACN,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE;gBAC7B,MAAM,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,WAAW,EAAE;gBAC7C,IAAI;aACL;YACD,IAAI;SACL,CAAC;IACJ,CAAC;CACF","sourcesContent":["import { getError } from '@venizia/ignis-helpers/core';\nimport {\n  UrlIngest,\n  UrlSafetyDefaults,\n  UrlSafetyErrors,\n  type IBucketRef,\n  type IObjectRef,\n  type IFileStat,\n  type IStorageHelper,\n  type IUploadResult,\n  type IUrlSafetyPolicy,\n} from '@venizia/ignis-helpers';\n\n/**\n * What was stored, and what the backend reports about it. The stat is returned because `getStat`\n * already ran to size the result - a caller writing its own row would otherwise pay for it twice.\n *\n * This does NOT write a meta link. The columns an application attaches to an object - a principal,\n * a variant - come from its own domain, not from the object, so the row stays the caller's.\n */\nexport interface IIngestFromUrlResult {\n  upload: IUploadResult;\n  stat: IFileStat;\n}\n\n/** Where a fetched object lands, and what it is attached to. */\nexport interface IIngestFromUrlOptions {\n  helper: IStorageHelper;\n  url: string;\n  bucket: IBucketRef;\n\n  /**\n   * Decides the stored key.\n   *\n   * **Absent, the key comes from the remote url's last path segment - which on an untrusted url is\n   * named by whoever supplied it.** Pass `resolveKey` whenever the url is not your own; the\n   * validation below bounds what it can do, but it does not make the remote name yours.\n   */\n  resolveKey?: (opts: { url: URL; contentType: string }) => string;\n  folderPath?: string;\n\n  /** Absent leaves IGNIS's own default: https only, no private address, 3 hops, 10s, 10 MB. */\n  policy?: IUrlSafetyPolicy;\n\n  /** Folder nesting the key may carry. Absent uses `BaseStorageHelper.DEFAULT_MAX_FOLDER_DEPTH`. */\n  maxFolderDepth?: number;\n\n  /**\n   * Where the object is served from. **Required**: an absent hook used to yield an empty link, which\n   * is exactly the value that satisfies a NOT NULL column and points nowhere.\n   */\n  normalizeLinkFn: (opts: { bucket: IBucketRef; object: IObjectRef }) => string;\n}\n\nconst readKeyFromUrl = (opts: { url: URL; folderPath?: string }): string => {\n  const { url, folderPath } = opts;\n  const lastSegment = url.pathname.split('/').filter(Boolean).pop() ?? 'object';\n  const normalized = lastSegment.toLowerCase().replace(/ /g, '_');\n\n  return folderPath ? `${folderPath}/${normalized}` : normalized;\n};\n\n/** Storing an object that came from somewhere else. */\nexport class AssetIngest {\n  /**\n   * Fetches an untrusted url and stores what comes back, without the bytes passing through this\n   * process: the guarded body is capped and handed to `writeStream` as a stream.\n   *\n   * The url is guarded by `UrlIngest.fetchGuarded` - scheme allow-list, every resolved address\n   * checked, redirects walked by hand with a per-hop re-check, and a timeout. A rebinding window\n   * remains open between the check and the connect; see `UrlIngest.assertPublicHost`.\n   *\n   * The served content type is decided from the stored KEY, never from what the remote host\n   * claimed - the same rule the asset routes apply, and for the same reason.\n   */\n  static async fromUrl(opts: IIngestFromUrlOptions): Promise<IIngestFromUrlResult> {\n    const { helper, url, bucket, folderPath, policy, resolveKey, normalizeLinkFn } = opts;\n\n    const response = await UrlIngest.fetchGuarded({ url, policy });\n    const remoteType = response.headers.get('content-type')?.split(';')[0]?.trim() ?? '';\n    const parsed = new URL(url);\n\n    const key = resolveKey\n      ? resolveKey({ url: parsed, contentType: remoteType })\n      : readKeyFromUrl({ url: parsed, folderPath });\n\n    // The helper's own default, not an unbounded one: an object arriving through ingest must obey\n    // the same depth rule as one arriving through the upload route.\n    if (!helper.isValidObjectKey({ object: { key }, maxDepth: opts.maxFolderDepth })) {\n      await response.body?.cancel();\n      throw getError({ message: `[AssetIngest.fromUrl] Invalid object key | key: ${key}` });\n    }\n\n    // Refused BEFORE the write starts, so a body that declares its size never opens a multipart\n    // upload at all. A body that lies or omits the header is caught mid-flight by `capStream`, and\n    // Bun's client answers that with `AbortMultipartUpload` - measured against a recording endpoint,\n    // not assumed - so no orphaned parts are left behind either way.\n    const declaredLength = Number(response.headers.get('content-length') ?? 0);\n    const maxBytes = policy?.maxBytes ?? UrlSafetyDefaults.MAX_BYTES;\n\n    if (declaredLength > maxBytes) {\n      await response.body?.cancel();\n      throw getError({\n        error: UrlSafetyErrors.URL_REFUSED,\n        message: `[AssetIngest.fromUrl] Body exceeds the cap | declared: ${declaredLength} | max: ${maxBytes}`,\n      });\n    }\n\n    if (!response.body) {\n      throw getError({ message: `[AssetIngest.fromUrl] Response carried no body | url: ${url}` });\n    }\n\n    const object: IObjectRef = { key };\n    const contentType = helper.getMimeType({ filename: key });\n\n    await helper.writeStream({\n      bucket,\n      object,\n      source: UrlIngest.capStream({ source: response.body, policy }),\n      contentType,\n      maxFolderDepth: opts.maxFolderDepth,\n    });\n\n    const stat = await helper.getStat({ bucket, object });\n    const link = normalizeLinkFn({ bucket, object });\n\n    if (!link) {\n      throw getError({\n        message: `[AssetIngest.fromUrl] normalizeLinkFn returned an empty link | key: ${key}`,\n      });\n    }\n\n    return {\n      upload: {\n        bucket: { name: bucket.name },\n        object: { key, size: stat.size, contentType },\n        link,\n      },\n      stat,\n    };\n  }\n}\n"]}

package/dist/esm/components/static-asset/models/base.model.d.ts

@@ -0,0 +1,576 @@
+import { BaseRelationalEntity, type TTableObject, type TTableSchemaWithId } from '@venizia/ignis-connectors/postgres';
+/** One row per (object, owner) pairing, NOT per object: one product image attached to the product and to each variant is the common case, so `(bucketName, objectName)` is indexed and deliberately NOT unique. */
+export declare class BaseMetaLinkModel extends BaseRelationalEntity<typeof BaseMetaLinkModel.schema> {
+    static schema: import("drizzle-orm/pg-core").PgTableWithColumns<{
+        name: "MetaLink";
+        schema: undefined;
+        columns: {
+            bucketName: import("drizzle-orm/pg-core").PgColumn<{
+                name: "bucket_name";
+                tableName: "MetaLink";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            objectName: import("drizzle-orm/pg-core").PgColumn<{
+                name: "object_name";
+                tableName: "MetaLink";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            link: import("drizzle-orm/pg-core").PgColumn<{
+                name: "link";
+                tableName: "MetaLink";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            mimetype: import("drizzle-orm/pg-core").PgColumn<{
+                name: "mimetype";
+                tableName: "MetaLink";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            size: import("drizzle-orm/pg-core").PgColumn<{
+                name: "size";
+                tableName: "MetaLink";
+                dataType: "number";
+                columnType: "PgInteger";
+                data: number;
+                driverParam: string | number;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            etag: import("drizzle-orm/pg-core").PgColumn<{
+                name: "etag";
+                tableName: "MetaLink";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            metadata: import("drizzle-orm/pg-core").PgColumn<{
+                name: "metadata";
+                tableName: "MetaLink";
+                dataType: "json";
+                columnType: "PgJsonb";
+                data: Record<string, any>;
+                driverParam: unknown;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: Record<string, any>;
+            }>;
+            storageType: import("drizzle-orm/pg-core").PgColumn<{
+                name: "storage_type";
+                tableName: "MetaLink";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            isSynced: import("drizzle-orm/pg-core").PgColumn<{
+                name: "is_synced";
+                tableName: "MetaLink";
+                dataType: "boolean";
+                columnType: "PgBoolean";
+                data: boolean;
+                driverParam: boolean;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            variant: import("drizzle-orm/pg-core").PgColumn<{
+                name: "variant";
+                tableName: "MetaLink";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            sequence: import("drizzle-orm/pg-core").PgColumn<{
+                name: "sequence";
+                tableName: "MetaLink";
+                dataType: "number";
+                columnType: "PgInteger";
+                data: number;
+                driverParam: string | number;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            principalType: import("drizzle-orm/pg-core").PgColumn<{
+                name: "principal_type";
+                tableName: "MetaLink";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            principalId: import("drizzle-orm/pg-core").PgColumn<{
+                name: "principal_id";
+                tableName: "MetaLink";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            createdAt: import("drizzle-orm/pg-core").PgColumn<{
+                name: string;
+                tableName: "MetaLink";
+                dataType: "custom";
+                columnType: "PgCustomColumn";
+                data: string | import("@venizia/ignis-filter").TIsoTimestamp;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                pgColumnBuilderBrand: "PgCustomColumnBuilderBrand";
+            }>;
+            modifiedAt: import("drizzle-orm/pg-core").PgColumn<{
+                name: string;
+                tableName: "MetaLink";
+                dataType: "custom";
+                columnType: "PgCustomColumn";
+                data: string | import("@venizia/ignis-filter").TIsoTimestamp;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                pgColumnBuilderBrand: "PgCustomColumnBuilderBrand";
+            }>;
+            id: import("drizzle-orm/pg-core").PgColumn<{
+                name: "id";
+                tableName: "MetaLink";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: true;
+                isAutoincrement: false;
+                hasRuntimeDefault: true;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+        } | {
+            bucketName: import("drizzle-orm/pg-core").PgColumn<{
+                name: "bucket_name";
+                tableName: "MetaLink";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            objectName: import("drizzle-orm/pg-core").PgColumn<{
+                name: "object_name";
+                tableName: "MetaLink";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            link: import("drizzle-orm/pg-core").PgColumn<{
+                name: "link";
+                tableName: "MetaLink";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            mimetype: import("drizzle-orm/pg-core").PgColumn<{
+                name: "mimetype";
+                tableName: "MetaLink";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            size: import("drizzle-orm/pg-core").PgColumn<{
+                name: "size";
+                tableName: "MetaLink";
+                dataType: "number";
+                columnType: "PgInteger";
+                data: number;
+                driverParam: string | number;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            etag: import("drizzle-orm/pg-core").PgColumn<{
+                name: "etag";
+                tableName: "MetaLink";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            metadata: import("drizzle-orm/pg-core").PgColumn<{
+                name: "metadata";
+                tableName: "MetaLink";
+                dataType: "json";
+                columnType: "PgJsonb";
+                data: Record<string, any>;
+                driverParam: unknown;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                $type: Record<string, any>;
+            }>;
+            storageType: import("drizzle-orm/pg-core").PgColumn<{
+                name: "storage_type";
+                tableName: "MetaLink";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            isSynced: import("drizzle-orm/pg-core").PgColumn<{
+                name: "is_synced";
+                tableName: "MetaLink";
+                dataType: "boolean";
+                columnType: "PgBoolean";
+                data: boolean;
+                driverParam: boolean;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            variant: import("drizzle-orm/pg-core").PgColumn<{
+                name: "variant";
+                tableName: "MetaLink";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            sequence: import("drizzle-orm/pg-core").PgColumn<{
+                name: "sequence";
+                tableName: "MetaLink";
+                dataType: "number";
+                columnType: "PgInteger";
+                data: number;
+                driverParam: string | number;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            principalType: import("drizzle-orm/pg-core").PgColumn<{
+                name: "principal_type";
+                tableName: "MetaLink";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            principalId: import("drizzle-orm/pg-core").PgColumn<{
+                name: "principal_id";
+                tableName: "MetaLink";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: false;
+                hasDefault: false;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+            createdAt: import("drizzle-orm/pg-core").PgColumn<{
+                name: string;
+                tableName: "MetaLink";
+                dataType: "custom";
+                columnType: "PgCustomColumn";
+                data: string | import("@venizia/ignis-filter").TIsoTimestamp;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                pgColumnBuilderBrand: "PgCustomColumnBuilderBrand";
+            }>;
+            modifiedAt: import("drizzle-orm/pg-core").PgColumn<{
+                name: string;
+                tableName: "MetaLink";
+                dataType: "custom";
+                columnType: "PgCustomColumn";
+                data: string | import("@venizia/ignis-filter").TIsoTimestamp;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: false;
+                isAutoincrement: false;
+                hasRuntimeDefault: false;
+                enumValues: undefined;
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {
+                pgColumnBuilderBrand: "PgCustomColumnBuilderBrand";
+            }>;
+            id: import("drizzle-orm/pg-core").PgColumn<{
+                name: "id";
+                tableName: "MetaLink";
+                dataType: "string";
+                columnType: "PgText";
+                data: string;
+                driverParam: string;
+                notNull: true;
+                hasDefault: true;
+                isPrimaryKey: true;
+                isAutoincrement: false;
+                hasRuntimeDefault: true;
+                enumValues: [string, ...string[]];
+                baseColumn: never;
+                identity: undefined;
+                generated: undefined;
+            }, {}, {}>;
+        };
+        dialect: "pg";
+    }>;
+    static relations: () => never[];
+}
+export type TMetaLinkSchema = typeof BaseMetaLinkModel.schema;
+export type TMetaLink = TTableObject<TMetaLinkSchema>;
+/** Any table whose row carries the MetaLink fields. The component reads and writes the ROW, so the table is free to carry another name or to live in another Postgres schema. */
+export type TMetaLinkCompatibleSchema = TTableSchemaWithId & {
+    $inferSelect: TMetaLink;
+};
+//# sourceMappingURL=base.model.d.ts.map

package/dist/esm/components/static-asset/models/base.model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.model.d.ts","sourceRoot":"","sources":["../../../../../src/components/static-asset/models/base.model.ts"],"names":[],"mappings":"AACA,OAAO,EACL,oBAAoB,EAGpB,KAAK,YAAY,EACjB,KAAK,kBAAkB,EACxB,MAAM,oCAAoC,CAAC;AAG5C,mNAAmN;AACnN,qBACa,iBAAkB,SAAQ,oBAAoB,CAAC,OAAO,iBAAiB,CAAC,MAAM,CAAC;IAC1F,OAAgB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCpB;IAEF,OAAgB,SAAS,gBAAY;CACtC;AAED,MAAM,MAAM,eAAe,GAAG,OAAO,iBAAiB,CAAC,MAAM,CAAC;AAC9D,MAAM,MAAM,SAAS,GAAG,YAAY,CAAC,eAAe,CAAC,CAAC;AAEtD,iLAAiL;AACjL,MAAM,MAAM,yBAAyB,GAAG,kBAAkB,GAAG;IAAE,YAAY,EAAE,SAAS,CAAA;CAAE,CAAC"}

package/dist/esm/components/static-asset/models/base.model.js

@@ -0,0 +1,45 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { model } from '../../../base/metadata/index.js';
+import { BaseRelationalEntity, generateIdColumnDefs, generateTzColumnDefs, } from '@venizia/ignis-connectors/postgres';
+import { boolean, index, integer, jsonb, pgTable, text } from 'drizzle-orm/pg-core';
+/** One row per (object, owner) pairing, NOT per object: one product image attached to the product and to each variant is the common case, so `(bucketName, objectName)` is indexed and deliberately NOT unique. */
+let BaseMetaLinkModel = class BaseMetaLinkModel extends BaseRelationalEntity {
+    static { this.schema = pgTable('MetaLink', {
+        ...generateIdColumnDefs({ id: { dataType: 'string' } }),
+        ...generateTzColumnDefs(),
+        bucketName: text('bucket_name').notNull(),
+        objectName: text('object_name').notNull(),
+        link: text().notNull(),
+        mimetype: text().notNull(),
+        size: integer().notNull(),
+        etag: text(),
+        metadata: jsonb().$type(),
+        storageType: text('storage_type').notNull(),
+        isSynced: boolean('is_synced').notNull().default(false),
+        /** An opaque label the caller chooses - a size, a role, a rendition name. The component stores and returns it and reads no meaning into it. */
+        variant: text(),
+        /** Display order within ONE principal. Defaults to 0 so legacy rows tie and `ORDER BY sequence, createdAt` reproduces the order they already had. */
+        sequence: integer().notNull().default(0),
+        /** A polymorphic owner: the type names the table, the id the row. Both nullable - an object may belong to nothing yet, which is how `recreate-metalink` writes one. */
+        principalType: text('principal_type'),
+        principalId: text('principal_id'),
+    }, (def) => [
+        index(`IDX_MetaLink_bucketName`).on(def.bucketName),
+        index(`IDX_MetaLink_objectName`).on(def.objectName),
+        index(`IDX_MetaLink_storageType`).on(def.storageType),
+        index(`IDX_MetaLink_isSynced`).on(def.isSynced),
+        // Ordering runs inside a principal filter, so filter columns lead and the sort column trails.
+        index(`IDX_MetaLink_principal_sequence`).on(def.principalType, def.principalId, def.sequence),
+    ]); }
+    static { this.relations = () => []; }
+};
+BaseMetaLinkModel = __decorate([
+    model({ migration: { use: false } })
+], BaseMetaLinkModel);
+export { BaseMetaLinkModel };
+//# sourceMappingURL=base.model.js.map

package/dist/esm/components/static-asset/models/base.model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.model.js","sourceRoot":"","sources":["../../../../../src/components/static-asset/models/base.model.ts"],"names":[],"mappings":";;;;;;AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACxC,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,oBAAoB,GAGrB,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AAEpF,mNAAmN;AAE5M,IAAM,iBAAiB,GAAvB,MAAM,iBAAkB,SAAQ,oBAAqD;aAC1E,WAAM,GAAG,OAAO,CAC9B,UAAU,EACV;QACE,GAAG,oBAAoB,CAAC,EAAE,EAAE,EAAE,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE,CAAC;QACvD,GAAG,oBAAoB,EAAE;QACzB,UAAU,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC,OAAO,EAAE;QACzC,UAAU,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC,OAAO,EAAE;QACzC,IAAI,EAAE,IAAI,EAAE,CAAC,OAAO,EAAE;QACtB,QAAQ,EAAE,IAAI,EAAE,CAAC,OAAO,EAAE;QAC1B,IAAI,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE;QACzB,IAAI,EAAE,IAAI,EAAE;QACZ,QAAQ,EAAE,KAAK,EAAE,CAAC,KAAK,EAAuB;QAC9C,WAAW,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC,OAAO,EAAE;QAC3C,QAAQ,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC;QAEvD,+IAA+I;QAC/I,OAAO,EAAE,IAAI,EAAE;QAEf,qJAAqJ;QACrJ,QAAQ,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;QAExC,uKAAuK;QACvK,aAAa,EAAE,IAAI,CAAC,gBAAgB,CAAC;QACrC,WAAW,EAAE,IAAI,CAAC,cAAc,CAAC;KAClC,EACD,CAAC,GAAG,EAAE,EAAE,CAAC;QACP,KAAK,CAAC,yBAAyB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,UAAU,CAAC;QACnD,KAAK,CAAC,yBAAyB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,UAAU,CAAC;QACnD,KAAK,CAAC,0BAA0B,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,WAAW,CAAC;QACrD,KAAK,CAAC,uBAAuB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC;QAC/C,8FAA8F;QAC9F,KAAK,CAAC,iCAAiC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,aAAa,EAAE,GAAG,CAAC,WAAW,EAAE,GAAG,CAAC,QAAQ,CAAC;KAC9F,CACF,AAjCqB,CAiCpB;aAEc,cAAS,GAAG,GAAG,EAAE,CAAC,EAAE,AAAX,CAAY;;AApC1B,iBAAiB;IAD7B,KAAK,CAAC,EAAE,SAAS,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,EAAE,CAAC;GACxB,iBAAiB,CAqC7B","sourcesContent":["import { model } from '@/base/metadata';\nimport {\n  BaseRelationalEntity,\n  generateIdColumnDefs,\n  generateTzColumnDefs,\n  type TTableObject,\n  type TTableSchemaWithId,\n} from '@venizia/ignis-connectors/postgres';\nimport { boolean, index, integer, jsonb, pgTable, text } from 'drizzle-orm/pg-core';\n\n/** One row per (object, owner) pairing, NOT per object: one product image attached to the product and to each variant is the common case, so `(bucketName, objectName)` is indexed and deliberately NOT unique. */\n@model({ migration: { use: false } })\nexport class BaseMetaLinkModel extends BaseRelationalEntity<typeof BaseMetaLinkModel.schema> {\n  static override schema = pgTable(\n    'MetaLink',\n    {\n      ...generateIdColumnDefs({ id: { dataType: 'string' } }),\n      ...generateTzColumnDefs(),\n      bucketName: text('bucket_name').notNull(),\n      objectName: text('object_name').notNull(),\n      link: text().notNull(),\n      mimetype: text().notNull(),\n      size: integer().notNull(),\n      etag: text(),\n      metadata: jsonb().$type<Record<string, any>>(),\n      storageType: text('storage_type').notNull(),\n      isSynced: boolean('is_synced').notNull().default(false),\n\n      /** An opaque label the caller chooses - a size, a role, a rendition name. The component stores and returns it and reads no meaning into it. */\n      variant: text(),\n\n      /** Display order within ONE principal. Defaults to 0 so legacy rows tie and `ORDER BY sequence, createdAt` reproduces the order they already had. */\n      sequence: integer().notNull().default(0),\n\n      /** A polymorphic owner: the type names the table, the id the row. Both nullable - an object may belong to nothing yet, which is how `recreate-metalink` writes one. */\n      principalType: text('principal_type'),\n      principalId: text('principal_id'),\n    },\n    (def) => [\n      index(`IDX_MetaLink_bucketName`).on(def.bucketName),\n      index(`IDX_MetaLink_objectName`).on(def.objectName),\n      index(`IDX_MetaLink_storageType`).on(def.storageType),\n      index(`IDX_MetaLink_isSynced`).on(def.isSynced),\n      // Ordering runs inside a principal filter, so filter columns lead and the sort column trails.\n      index(`IDX_MetaLink_principal_sequence`).on(def.principalType, def.principalId, def.sequence),\n    ],\n  );\n\n  static override relations = () => [];\n}\n\nexport type TMetaLinkSchema = typeof BaseMetaLinkModel.schema;\nexport type TMetaLink = TTableObject<TMetaLinkSchema>;\n\n/** Any table whose row carries the MetaLink fields. The component reads and writes the ROW, so the table is free to carry another name or to live in another Postgres schema. */\nexport type TMetaLinkCompatibleSchema = TTableSchemaWithId & { $inferSelect: TMetaLink };\n"]}

package/dist/esm/components/static-asset/models/index.d.ts

@@ -0,0 +1,2 @@
+export * from './base.model.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/components/static-asset/models/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/components/static-asset/models/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC"}

package/dist/esm/components/static-asset/models/index.js

@@ -0,0 +1,2 @@
+export * from './base.model.js';
+//# sourceMappingURL=index.js.map

package/dist/esm/components/static-asset/models/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/components/static-asset/models/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC","sourcesContent":["export * from './base.model';\n"]}